# Java创建多线程的几种方式 

[TOC]

## 1、继承Thread类，重写run()方法 

```java
//方式1
package cn.itcats.thread.Test1;

public class Demo1 extends Thread{
	
    //重写的是父类Thread的run()
	public void run() {
		System.out.println(getName()+"is running...");
	}
	
	
	public static void main(String[] args) {
		Demo1 demo1 = new Demo1();
		Demo1 demo2 = new Demo1();
		demo1.start();
		demo2.start();
	}
}
```

## 2、实现Runnable接口，重写run() 

实现Runnable接口只是完成了线程任务的编写  
若要启动线程，需要new Thread(Runnable target)，再有thread对象调用start()方法启动线程  
此处我们只是重写了Runnable接口的Run()方法，并未重写Thread类的run()，让我们看看Thread类run()的实现  
本质上也是调用了我们传进去的Runnale target对象的run()方法

```java
//Thread类源码中的run()方法
//target为Thread 成员变量中的 private Runnable target;

 @Override
    public void run() {
        if (target != null) {
            target.run();
        }
    }
```

所以第二种创建线程的实现代码如下：

```java
package cn.itcats.thread.Test1;

/**
 * 第二种创建启动线程的方式
 * 实现Runnale接口
 * @author fatah
 */
public class Demo2 implements Runnable{

    //重写的是Runnable接口的run()
	public void run() {
			System.out.println("implements Runnable is running");
	}
	
	public static void main(String[] args) {
		Thread thread1 = new Thread(new Demo2());
		Thread thread2 = new Thread(new Demo2());
		thread1.start();
		thread2.start();
	}

}
```

实现Runnable接口相比第一种继承Thread类的方式，使用了面向接口，将任务与线程进行分离，有利于解耦

## 3、匿名内部类的方式 

适用于创建启动线程次数较少的环境，书写更加简便  
具体代码实现：

```java
package cn.itcats.thread.Test1;
/**
 * 创建启动线程的第三种方式————匿名内部类
 * @author fatah
 */
public class Demo3 {
	public static void main(String[] args) {
		//方式1：相当于继承了Thread类，作为子类重写run()实现
		new Thread() {
			public void run() {
				System.out.println("匿名内部类创建线程方式1...");
			};
		}.start();
		
		
		
		//方式2:实现Runnable,Runnable作为匿名内部类
		new Thread(new Runnable() {
			public void run() {
				System.out.println("匿名内部类创建线程方式2...");
			}
		} ).start();
	}
}
```

## 4、带返回值的线程(实现implements Callable<返回值类型>) 

以上两种方式，都没有返回值且都无法抛出异常。  
Callable和Runnbale一样代表着任务，只是Callable接口中不是run()，而是call()方法，但两者相似，即都表示执行任务，call()方法的返回值类型即为Callable接口的泛型  
具体代码实现：

```java
package cn.itcats.thread.Test1;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import java.util.concurrent.FutureTask;
import java.util.concurrent.RunnableFuture;

/**
 * 方式4:实现Callable<T> 接口
 * 含返回值且可抛出异常的线程创建启动方式
 * @author fatah
 */
public class Demo5 implements Callable<String>{

	public String call() throws Exception {
		System.out.println("正在执行新建线程任务");
		Thread.sleep(2000);
		return "新建线程睡了2s后返回执行结果";
	}

	public static void main(String[] args) throws InterruptedException, ExecutionException {
		Demo5 d = new Demo5();
		/*	call()只是线程任务,对线程任务进行封装
			class FutureTask<V> implements RunnableFuture<V>
			interface RunnableFuture<V> extends Runnable, Future<V>
		*/
		FutureTask<String> task = new FutureTask<>(d);
		Thread t = new Thread(task);
		t.start();
		System.out.println("提前完成任务...");
		//获取任务执行后返回的结果
		String result = task.get();
		System.out.println("线程执行结果为"+result);
	}
	
}
```

## 5、定时器(java.util.Timer) 

关于Timmer的几个构造方法  
![ThirdPartyImage_1e755b90.png](http://markdown.liangtengyu.com:9998/images/ThirdPartyImage_1e755b90.png)  

执行定时器任务使用的是schedule方法：  
![ThirdPartyImage_140f21df.png](http://markdown.liangtengyu.com:9998/images/ThirdPartyImage_140f21df.png)  

具体代码实现：

```java
package cn.itcats.thread.Test1;

import java.util.Timer;
import java.util.TimerTask;

/**
 * 方法5：创建启动线程之Timer定时任务
 * @author fatah
 */
public class Demo6 {
	public static void main(String[] args) {
		Timer timer = new Timer();
		timer.schedule(new TimerTask() {
			@Override
			public void run() {
				System.out.println("定时任务延迟0(即立刻执行),每隔1000ms执行一次");
			}
		}, 0, 1000);
	}
	
}
```

我们发现Timer有不可控的缺点，当任务未执行完毕或我们每次想执行不同任务时候，实现起来比较麻烦。这里推荐一个比较优秀的开源作业调度框架“quartz”，在后期我可能会写一篇关于quartz的博文。

## 6、线程池的实现(java.util.concurrent.Executor接口) 

降低了创建线程和销毁线程时间开销和资源浪费  
具体代码实现：

```java
package cn.itcats.thread.Test1;

import java.util.concurrent.Executor;
import java.util.concurrent.Executors;

public class Demo7 {
	public static void main(String[] args) {
		//创建带有5个线程的线程池
		//返回的实际上是ExecutorService,而ExecutorService是Executor的子接口
		Executor threadPool = Executors.newFixedThreadPool(5);
		for(int i = 0 ;i < 10 ; i++) {
			threadPool.execute(new Runnable() {
				public void run() {
					System.out.println(Thread.currentThread().getName()+" is running");
				}
			});
		}
		
	}
}
```

运行结果：  
pool-1-thread-3 is running  
pool-1-thread-1 is running  
pool-1-thread-4 is running  
pool-1-thread-3 is running  
pool-1-thread-5 is running  
pool-1-thread-2 is running  
pool-1-thread-5 is running  
pool-1-thread-3 is running  
pool-1-thread-1 is running  
pool-1-thread-4 is running  

运行完毕，但程序并未停止，原因是线程池并未销毁，若想销毁调用threadPool.shutdown(); 注意需要把我上面的  
Executor threadPool = Executors.newFixedThreadPool(10); 改为  
ExecutorService threadPool = Executors.newFixedThreadPool(10); 否则无shutdown()方法  

若创建的是CachedThreadPool则不需要指定线程数量，线程数量多少取决于线程任务，不够用则创建线程，够用则回收。

## 7、Lambda表达式的实现(parallelStream)



```java
package cn.itcats.thread.Test1;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

/**
 * 使用Lambda表达式并行计算
 * parallelStream
 * @author fatah
 */
public class Demo8 {
	public static void main(String[] args) {
		List<Integer> list = Arrays.asList(1,2,3,4,5,6);
		Demo8 demo = new Demo8();
		int result = demo.add(list);
		System.out.println("计算后的结果为"+result);
	}
	
	public int add(List<Integer> list) {
		//若Lambda是串行执行,则应顺序打印
		list.parallelStream().forEach(System.out :: println);
		//Lambda有stream和parallelSteam(并行)
		return list.parallelStream().mapToInt(i -> i).sum();
	}
}
```

运行结果：  
4  
1  
3  
5  
6  
2  
计算后的结果为21  
事实证明是并行执行  

## 8、Spring实现多线程 



### (1)新建Maven工程导入spring相关依赖  

###  (2)新建一个java配置类(注意需要开启@EnableAsync注解——支持异步任务) 

```java
package cn.itcats.thread;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.EnableAsync;

@Configuration
@ComponentScan("cn.itcats.thread")
@EnableAsync
public class Config {
	
}
```

### (3)书写异步执行的方法类(注意方法上需要有@Async——异步方法调用) 

```java
package cn.itcats.thread;

import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;

@Service
public class AsyncService {
	
	@Async
	public void Async_A() {
		System.out.println("Async_A is running");
	}
	
	@Async
	public void Async_B() {
		System.out.println("Async_B is running");
	}
}
```

### (4)创建运行类 

```java
package cn.itcats.thread;

import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class Run {
	public static void main(String[] args) {
		//构造方法传递Java配置类Config.class
		AnnotationConfigApplicationContext ac = new AnnotationConfigApplicationContext(Config.class);
		AsyncService bean = ac.getBean(AsyncService.class);
		bean.Async_A();
		bean.Async_B();
	}
}
```


Java创建多线程的几种方式

### CAS  (Compare and Swap)

CAS字面意思为比较并交换.CAS 有 3 个操作数，分别是：内存值 M，期望值 E，更新值 U。当且仅当内存值 M 和期望值 E 相等时，将内存值 M 修改为 U，否则什么都不做。

### 1.CAS的应用场景

**CAS 只适用于线程冲突较少的情况**。

CAS 的典型应用场景是：

- 原子类
- 自旋锁

#### 1.1 原子类

> 原子类是 CAS 在 Java 中最典型的应用。

我们先来看一个常见的代码片段。

```
if(a==b) {
    a++;
}
```

如果 `a++` 执行前， a 的值被修改了怎么办？还能得到预期值吗？出现该问题的原因是在并发环境下，以上代码片段不是原子操作，随时可能被其他线程所篡改。

解决这种问题的最经典方式是应用原子类的 `incrementAndGet` 方法。

```java
public class AtomicIntegerDemo {

    public static void main(String[] args) throws InterruptedException {
        ExecutorService executorService = Executors.newFixedThreadPool(3);
        final AtomicInteger count = new AtomicInteger(0);
        for (int i = 0; i < 10; i++) {
            executorService.execute(new Runnable() {
                @Override
                public void run() {
                    count.incrementAndGet();
                }
            });
        }

        executorService.shutdown();
        executorService.awaitTermination(3, TimeUnit.SECONDS);
        System.out.println("Final Count is : " + count.get());
    }

}
```

J.U.C 包中提供了 `AtomicBoolean`、`AtomicInteger`、`AtomicLong` 分别针对 `Boolean`、`Integer`、`Long` 执行原子操作，操作和上面的示例大体相似，不做赘述。

#### 1.2 自旋锁

利用原子类（本质上是 CAS），可以实现自旋锁。

所谓自旋锁，是指线程反复检查锁变量是否可用，直到成功为止。由于线程在这一过程中保持执行，因此是一种忙等待。一旦获取了自旋锁，线程会一直保持该锁，直至显式释放自旋锁。

示例：非线程安全示例

```java
public class AtomicReferenceDemo {

    private static int ticket = 10;

    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(3);
        for (int i = 0; i < 5; i++) {
            executorService.execute(new MyThread());
        }
        executorService.shutdown();
    }

    static class MyThread implements Runnable {

        @Override
        public void run() {
            while (ticket > 0) {
                System.out.println(Thread.currentThread().getName() + " 卖出了第 " + ticket + " 张票");
                ticket--;
            }
        }

    }

}
```

输出结果：

```
pool-1-thread-2 卖出了第 10 张票
pool-1-thread-1 卖出了第 10 张票
pool-1-thread-3 卖出了第 10 张票
pool-1-thread-1 卖出了第 8 张票
pool-1-thread-2 卖出了第 9 张票
pool-1-thread-1 卖出了第 6 张票
pool-1-thread-3 卖出了第 7 张票
pool-1-thread-1 卖出了第 4 张票
pool-1-thread-2 卖出了第 5 张票
pool-1-thread-1 卖出了第 2 张票
pool-1-thread-3 卖出了第 3 张票
pool-1-thread-2 卖出了第 1 张票
```

很明显，出现了重复售票的情况。

【示例】使用自旋锁来保证线程安全

可以通过自旋锁这种非阻塞同步来保证线程安全，下面使用 `AtomicReference` 来实现一个自旋锁。

```java
public class AtomicReferenceDemo2 {

    private static int ticket = 10;

    public static void main(String[] args) {
        threadSafeDemo();
    }

    private static void threadSafeDemo() {
        SpinLock lock = new SpinLock();
        ExecutorService executorService = Executors.newFixedThreadPool(3);
        for (int i = 0; i < 5; i++) {
            executorService.execute(new MyThread(lock));
        }
        executorService.shutdown();
    }

    static class SpinLock {

        private AtomicReference<Thread> atomicReference = new AtomicReference<>();

        public void lock() {
            Thread current = Thread.currentThread();
            while (!atomicReference.compareAndSet(null, current)) {}
        }

        public void unlock() {
            Thread current = Thread.currentThread();
            atomicReference.compareAndSet(current, null);
        }

    }

    static class MyThread implements Runnable {

        private SpinLock lock;

        public MyThread(SpinLock lock) {
            this.lock = lock;
        }

        @Override
        public void run() {
            while (ticket > 0) {
                lock.lock();
                if (ticket > 0) {
                    System.out.println(Thread.currentThread().getName() + " 卖出了第 " + ticket + " 张票");
                    ticket--;
                }
                lock.unlock();
            }
        }

    }

}
```

输出结果：

```
pool-1-thread-2 卖出了第 10 张票
pool-1-thread-1 卖出了第 9 张票
pool-1-thread-3 卖出了第 8 张票
pool-1-thread-2 卖出了第 7 张票
pool-1-thread-3 卖出了第 6 张票
pool-1-thread-1 卖出了第 5 张票
pool-1-thread-2 卖出了第 4 张票
pool-1-thread-1 卖出了第 3 张票
pool-1-thread-3 卖出了第 2 张票
pool-1-thread-1 卖出了第 1 张票
```

### 2.CAS 的原理

Java 主要利用 `Unsafe` 这个类提供的 CAS 操作。`Unsafe` 的 CAS 依赖的是 JVM 针对不同的操作系统实现的硬件指令 **`Atomic::cmpxchg`**。`Atomic::cmpxchg` 的实现使用了汇编的 CAS 操作，并使用 CPU 提供的 `lock` 信号保证其原子性。

### 3.CAS 带来的问题

一般情况下，CAS 比锁性能更高。因为 CAS 是一种非阻塞算法，所以其避免了线程阻塞和唤醒的等待时间。

但是，事物总会有利有弊，CAS 也存在三大问题：

- ABA 问题
- `循环时间长开销大`
- `只能保证一个共享变量的原子性`

如何解决这三个问题:

#### 3.1  ABA 问题

**如果一个变量初次读取的时候是 A 值，它的值被改成了 B，后来又被改回为 A，那 CAS 操作就会误认为它从来没有被改变过**。

J.U.C 包提供了一个带有标记的**原子引用类  如:`AtomicStampedReference` 来解决这个问题**，它可以通过控制变量值的版本来保证 CAS 的正确性。大部分情况下 ABA 问题不会影响程序并发的正确性，如果需要解决 ABA 问题，改用**传统的互斥同步可能会比原子类更高效**。
解决方案：增加标志位，例如：AtomicMarkableReference、AtomicStampedReference

#### 3.2  循环时间长开销大

**自旋 CAS （不断尝试，直到成功为止）如果长时间不成功，会给 CPU 带来非常大的执行开销**。

如果 JVM 能支持处理器提供的 `pause` 指令那么效率会有一定的提升，`pause` 指令有两个作用：

- 它可以延迟流水线执行指令（de-pipeline）,使 CPU 不会消耗过多的执行资源，延迟的时间取决于具体实现的版本，在一些处理器上延迟时间是零。
- 它可以避免在退出循环的时候因内存顺序冲突（memory order violation）而引起 CPU 流水线被清空（CPU pipeline flush），从而提高 CPU 的执行效率。

解决方案：因为是while循环，消耗必然大。设置尝试次数上限

#### 3.3只能保证一个共享变量的原子性

当对一个共享变量执行操作时，我们可以使用循环 CAS 的方式来保证原子操作，但是对多个共享变量操作时，循环 CAS 就无法保证操作的原子性，这个时候就可以用锁。

或者有一个取巧的办法，就是把多个共享变量合并成一个共享变量来操作。比如有两个共享变量 `i ＝ 2, j = a`，合并一下 `ij=2a`，然后用 CAS 来操作 `ij`。从 Java 1.5 开始 JDK 提供了 `AtomicReference` 类来保证引用对象之间的原子性
解决方案：用AtomicReference把多个变量封装成一个对象来进行CAS操作.



Java多线程之CAS

深入理解 Java 并发锁



ReentrantLock类的大部分逻辑，都是其均继承自AQS的内部类Sync实现的

### 啥是AQS:

Java并发编程核心在于java.concurrent.util包而juc当中的大多数同步器实现都是围绕着共同的基础行为，比如**等待队列、条件队列、独占获取、共享获取**等，而这个行为的抽象就是基于AbstractQueuedSynchronizer简称AQS 它定义了一套多线程访问共享资源的同步器框架，是一个**依赖状态(state)的同步器**。

以公平锁为例子:

```java
    public static void main(String[] args) {
        ReentrantLock lock = new ReentrantLock(true);
        lock.lock(); //加锁 断点处
        try {
            Thread.sleep(5000);
        }catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
          lock.unlock();
        }
    
```

#### 公平锁、非公平锁

```java
public ReentrantLock(boolean fair) { //ReetrantLock的有参构造函数
    sync = fair ? new FairSync() : new NonfairSync();
}
```



在加锁行打断点运行,  我们可以看到参数:

![image-20201105163128535](http://localhost:9998/pic/image-20201105163128535.png)

​	`记住这几个值,后面会用到.`



单步步入 F7

![image-20201105163427610](http://localhost:9998/pic/image-20201105163427610.png)

看到lock()调用了Sync实例中的lock()方法

我们可以看到Sync是在ReentrantLock类中的一个抽象内部类 继承于AbstractQueuedSynchronizer (AQS)(抽象队列同步器)
![image-20201105163720831](http://localhost:9998/pic/image-20201105163720831.png)

点击Sync类中lock抽象接口方法 我们可以发现ReetrantLock有公平和非公平锁两种方式实现方式.由于本章我们使用公平锁讲解所以我们选择公平锁的实现方式继续向下调试代码
![image-20201105165340504](http://localhost:9998/pic/image-20201105165340504.png)

```java
 /**
     * Sync object for fair locks
     */
    static final class FairSync extends Sync { //公平锁实现方式 继承于Sync
        private static final long serialVersionUID = -3000897897090466540L;

        final void lock() {
            acquire(1);//获取锁 传入参数1
        }
..
```

向下⬇️

```java
  public final void acquire(int arg) {  //acquire方法接收参数 1
        if (!tryAcquire(arg) && acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
          	//这里有两个操作 使用短路与 如果第一个操作成功第二个操作不执行
						//1.尝试以独占模式获取锁,在成功时返回 
						//2.线程进入队列排队
            selfInterrupt();
    }
```

### 方式1 首先尝试获取锁 

```java
  /**
         * Fair version of tryAcquire.  Don't grant access unless
         * recursive call or no waiters or is first.
         */
        protected final boolean tryAcquire(int acquires) {  //参数:1
            final Thread current = Thread.currentThread();  //获取当前线程
            int c = getState();	//还记得我们第一个断点截图的state值是0
            if (c == 0) {			//是0 说明我们是第一次获取锁,如果不是0说明是重入,会进入else
                if (!hasQueuedPredecessors() &&
									//公平锁和非公平锁，主要是在方法 tryAcquire 中，是否有 !hasQueuedPredecessors() 判断。
                    compareAndSetState(0, acquires)) {//通过cas操作state更新,期望值是0,新值是1
                    setExclusiveOwnerThread(current);//设置当前拥有独占访问的线程。
                    return true;
                }
            }
            else if (current == getExclusiveOwnerThread()) { //如果 是重入情况 会进入这里.
										//进入前会判断是否是当前线程拿的锁
                int nextc = c + acquires; //假设重入次数为2  那么nextc = 2+1 =3
                if (nextc < 0)
                    throw new Error("Maximum lock count exceeded");
                setState(nextc); //更新state值
                return true;
            }
            return false;
        }
```

先判断state是否为0，**如果为0就执行上面提到的lock方法的前半部分**，通过CAS操作将state的值从0变为1，否则判断当前线程是否为exclusiveOwnerThread，然后把state++，也就是重入锁的体现，**我们注意前半部分是通过CAS来保证同步，后半部分并没有同步的体现**，原因是：后半部分是线程重入，再次获得锁时才触发的操作，此时当前线程拥有锁，所以对ReentrantLock的属性操作是无需加锁的。**如果tryAcquire()获取失败，则要执行addWaiter()向等待队列中添加一个独占模式的节点。**

```java
public final boolean hasQueuedPredecessors() {
    Node t = tail; // 根据初始化顺序倒序获取字段
    Node h = head;
    Node s;
    return h != t &&
        ((s = h.next) == null || s.thread != Thread.currentThread());
}
//在这个判断中主要就是看当前线程是不是同步队列的首位，是：true、否：false
//这部分涉及公平锁的实现，CLH（Craig，Landin andHagersten）。三个作者的首字母组合
```

### 啥是CLH

CLH锁即Craig, Landin, and Hagersten (CLH) locks。CLH锁是一个自旋锁。能确保无饥饿性。提供先来先服务的公平性。
为什么说JUC中的实现是基于CLH的“变种”，因为原始CLH队列，一般用于实现自旋锁。而JUC中的实现，获取不到锁的线程，一般会时而阻塞，时而唤醒。

![image-20201106144400019](http://localhost:9998/pic/image-20201106144400019.png)
1.获取不到锁的线程，会进入队尾，然后自旋，直到其前驱线程释放锁,具体位置是放在tail后的null位置,并让新对象的next指向Null 
2.如果head成功拿到了锁 此时 把head中包含的线程指向为Null并将head的前任设置为head后清除现任head

### 方式2 没获取到锁,需要进入队列排队:

进入方式需要`改造项目`让多个线程进行`抢占资源`改造如下:

```java
import java.util.concurrent.locks.ReentrantLock;

class Scratch {
    public static void main(String[] args) {
        ReentrantLock lock = new ReentrantLock(true);
        for (int i = 0; i < 5; i++) {
            new Thread(()->{
                lock.lock();
                try {
                    Thread.sleep(100);
                    System.out.println(Thread.currentThread().getName()+"工作结束....");
                }catch (InterruptedException e) {
                    e.printStackTrace();
                }finally {
                    lock.unlock();
                }
            }).start();
        }
    }
}
```

回到这里发现等待队列addWaiter方法添加了一个Null   将自己加入CLH队列的尾部 	关注公众号:[JAVA宝典]

![image-20201105171529838](http://localhost:9998/pic/image-20201105171529838.png)

发现等待队列addWaiter方法添加了一个Null  null的含义是:
![image-20201105171624412](http://localhost:9998/pic/image-20201105171624412.png)

使用null是`私有占用资源模式`,使用new Node()是 `共享模式`.(顺带一提,writelock不互斥,就是使用的共享模式)

Node还有几个等待状态:

```java
 /**
         * Status field, taking on only the values:
         *   SIGNAL:     The successor of this node is (or will soon be)
         *               blocked (via park), so the current node must
         *               unpark its successor when it releases or
         *               cancels. To avoid races, acquire methods must
         *               first indicate they need a signal,
         *               then retry the atomic acquire, and then,
         *               on failure, block.
         *   CANCELLED:  This node is cancelled due to timeout or interrupt.
         *               Nodes never leave this state. In particular,
         *               a thread with cancelled node never again blocks.
         *   CONDITION:  This node is currently on a condition queue.
         *               It will not be used as a sync queue node
         *               until transferred, at which time the status
         *               will be set to 0. (Use of this value here has
         *               nothing to do with the other uses of the
         *               field, but simplifies mechanics.)
         *   PROPAGATE:  A releaseShared should be propagated to other
         *               nodes. This is set (for head node only) in
         *               doReleaseShared to ensure propagation
         *               continues, even if other operations have
         *               since intervened.
         *   0:          None of the above
         *
         * The values are arranged numerically to simplify use.
         * Non-negative values mean that a node doesn't need to
         * signal. So, most code doesn't need to check for particular
         * values, just for sign.
         *
         * The field is initialized to 0 for normal sync nodes, and
         * CONDITION for condition nodes.  It is modified using CAS
         * (or when possible, unconditional volatile writes).
         */
        volatile int waitStatus;
```





在addWaiter(Node.EXCLUSIVE)处断点: 

```java
 /**
     * 根据给定的模式为当前节点创建一个Node
     *
     * @param mode Node.EXCLUSIVE for exclusive, Node.SHARED for shared
			//
     * @return the new node
     */
    private Node addWaiter(Node mode) {
        //线程对应的Node
        Node node = new Node(Thread.currentThread(), mode);
        // Try the fast path of enq; backup to full enq on failure
        Node pred = tail;
        //尾节点不为空
        if (pred != null) {
            //当前node的前驱指向尾节点
            node.prev = pred;
            //将当前node设置为新的尾节点
            //如果cas操作失败，说明线程竞争
            if (compareAndSetTail(pred, node)) {
                pred.next = node;
                return node;
            }
        }
        //lockfree的方式插入队尾
        enq(node);  //只有在 tail == null时才进入
        return node;
    }
```

先找到等待队列的tail节点pred，如果pred！=null，就把当前线程添加到pred后面进入等待队列，如果不存在tail节点执行enq()

```java
    private Node enq(final Node node) {
        //经典的lockfree算法：循环+CAS
        for (;;) {
            Node t = tail;
            //尾节点为空
            if (t == null) { // Must initialize
                //初始化头节点
                if (compareAndSetHead(new Node()))
                    tail = head;
            } else {
                node.prev = t;
                if (compareAndSetTail(t, node)) {
                    t.next = node;
                    return t;
                }
            }
        }
    }
```

这里进行了循环，**如果此时存在了tail就执行同上一步骤的添加队尾操作，如果依然不存在，就把当前线程作为head结点。**
插入节点后，调用acquireQueued()进行阻塞

```java
    /**
     * Acquires in exclusive uninterruptible mode for thread already in
     * queue. Used by condition wait methods as well as acquire.
     *
     * @param node the node
     * @param arg the acquire argument
     * @return {@code true} if interrupted while waiting
     */
    final boolean acquireQueued(final Node node, int arg) {
        boolean failed = true;
        try {
            boolean interrupted = false;
            for (;;) {
                final Node p = node.predecessor();
                if (p == head && tryAcquire(arg)) {
                    setHead(node);
                    p.next = null; // help GC
                    failed = false;
                    return interrupted;
                }
                if (shouldParkAfterFailedAcquire(p, node) &&
                    parkAndCheckInterrupt())
                    interrupted = true;
            }
        } finally {
            if (failed)
                cancelAcquire(node);
        }
    }
```

先获取当前节点的前一节点p，如果p是head的话就再进行一次tryAcquire(arg)操作，如果成功就返回，否则就执行**shouldParkAfterFailedAcquire、parkAndCheckInterrupt来达到阻塞效果；**

### 

### unlock

在unlock处打断点

进入了

```java
    public void unlock() {
        sync.release(1);
    }

```

![image-20201106142501425](http://localhost:9998/pic/image-20201106142501425.png)

继续跟进发现进入release方法,继续查看tryRelease(arg)方法

尝试释放锁有三种实现 我们点ReetrantLock实现方式
![image-20201106142623929](http://localhost:9998/pic/image-20201106142623929.png)

源码:
![image-20201106142942146](http://localhost:9998/pic/image-20201106142942146.png)

```java
        protected final boolean tryRelease(int releases) { //最后进入到实际解锁源码中
            int c = getState() - releases;
            if (Thread.currentThread() != getExclusiveOwnerThread()) //判断持有线程和当前执行线程是否是同一个,否则报错
                throw new IllegalMonitorStateException();
            boolean free = false;
            if (c == 0) { //判断释放掉releases参数后是否是0 如果 为0 设置当前排他锁的占有线程为Null
                free = true;
                setExclusiveOwnerThread(null);
            }
            setState(c);//更新state为0
            return free;//返回解锁是否成功
        }
```



Java创建多线程的几种方式

1、继承Thread类，重写run()方法

CAS (Compare and Swap)

深入理解 Java 并发锁

1. 并发锁简介