目录

• JUC概述
• • 什么是JUC
  • 进程与线程的概念
  • • 线程的状态
    • 线程的方法
    • 并发与并行
    • 管程(Monitor)
    • 用户线程和守护线程
• Lock接口
• • Synchronized 关键字
  • • Synchronized 作用范围
    • Synchronized 实现卖票例子
  • Lock接口
  • • 什么是Lock
    • Lock与synchronized的区别
    • 可重入锁（ReentrantLock）
    • • 使用ReentrantLock实现卖票
    • 读写锁
  • 创建线程的多种方式
• 线程间通信
• • 什么是线程间通信
  • 小例子
  • • synchronized实现
    • 线程间虚假唤醒问题
    • 如何解决虚假唤醒
    • Lock实现
  • 线程间定制化通信
  • • 使用 volatile 关键字
• 多线程编程步骤
• 集合线程安全
• • ArrayList
  • • 异常演示
    • 解决方案1-Vector
    • 解决方案2-Collections
    • 解决方案3-CopyOnWriteArrayList
    • • 什么是写时复制技术
  • HashSet
  • HashMap
• 多线程锁（synchronized线程8锁）
• 公平锁和非公平锁
• 可重入锁1（ReentrantLock）
• • 什么是可重入锁
  • synchronized演示可重入锁
  • Lock演示可重入锁
• 死锁
• • 什么是死锁
  • 验证是否是死锁
• Callable接口
• • FutureTask原理（未来任务）
• JUC 辅助类
• • CountDownLatch
  • CycleBarrier（循环栅栏）
  • Semaphore（信号灯）
• 读写锁
• • 锁
  • 读写锁的演变！！！
  • 读写锁案例（ReentractReadWirtLock）
  • • volatile 关键字
    • 案例
    • 锁降级！！！
• 阻塞队列
• • BlockingQueue（阻塞队列）
  • 阻塞队列的分类
  • • ArrayBlockingQueue
    • LinkedBloking Queue
    • TransferQueue
    • DelayQueue
    • SynchronousQueue
    • PriorityBlockingQueue
• 线程池
• • 常用的线程池
  • 线程池的原理
  • • 线程池的工作流程和拒绝策略
  • 自定义线程池
• Fork Join
• CompletableFuture.runAsync 异步任务
• • • 什么是同步？什么是异步
    • 使用场景及案例
    • 无返回值的异步任务
    • 有返回值的异步任务

JUC概述

oracle 官方java文档
java 中文文档

什么是JUC

JUC是Java并发编程包

进程与线程的概念

1. 进程是系统中正在运行的一个应用程序，程序一旦运行就是进程，例如我们在结束某些卡死的应用时，打开任务管理器结束该进程；进程是资源分配的最小单位；
2. 线程：系统分配锤炼器时间资源的基本单元，或者说进程之内独立执行的一个单元执行流。线程是程序执行的最小单位。

线程的状态

1. new(新建)
2. runnable(准备就绪)
3. blocked(阻塞)
4. waiting(等待-不见不散)
5. timed_waiting(等待-过时不候)
6. terminated(终结)

线程的方法

wait 和sleep

1. sleep是Thread的静态方法，wait是object的方法，任何对象实例都能调用
2. sleep不会释放锁，他也不需要占用锁。wait会释放锁，但调用它的前提是当前线程占有锁（即代码要在synchronized中）。
3. 它们都可以被interrupted方法中断

并发与并行

1. 并发：同一时刻多个线程在访问同一个资源，多个线程对一个点，例如春运抢票 电商秒杀
2. 并行：多项工作一起执行，之后再汇总，例如洗衣服和做饭和听音乐可以同时进行，

管程(Monitor)

管程，也就是Monitor，在Java中叫锁，在操作系统中叫监视器，是一种同步机制，保证同一个时间，只有一个线程访问被保护的数据或者代码。

JVM中的同步是基于进入和退出操作实现的，而进入和退出是基于管程对象实现的，每一个对象都有一个管程对象，管程对象会随着Java对象的创建和销毁而创建或者销毁，例如在执行线程操作的时候，首先要持有这个线程的管程对象，然后再执行方法，当你在执行方法的时候，其他线程就不能持有同一个管程对象，当你的 方法执行完毕后，再释放管程对象，交给其他线程处理，通过这种方式来实现多线程中加锁的操作。

用户线程和守护线程

用户线程：例如new thread 这就是用户线程
守护线程：例如垃圾回收就是守护线程，在后台默默的执行

 public static void main(String[] args) {Thread thread = new Thread(()->{//isDaemon方法如果返回true就表示是守护线程，如果是false就表示是用户线程System.out.println(Thread.currentThread().getName() + "::" + Thread.currentThread().isDaemon());while (true){}},"UserThread");thread.start();System.out.println(Thread.currentThread().getName());}

打印结果：先打印出了main线程，然后userThread 为false表示该线程是用户线程。此时主线程已经结束，但是用户线程还是存活并执行的情况，而且jvm也是在运行中。

那么接下来我们将userThread设置为守护线程看一下，如下，此时我们发现打印结果

 public static void main(String[] args) {Thread thread = new Thread(()->{//isDaemon方法如果返回true就表示是守护线程，如果是false就表示是用户线程System.out.println(Thread.currentThread().getName() + "::" + Thread.currentThread().isDaemon());while (true){}},"UserThread");thread.setDaemon(ture);//设置userThread为守护线程thread.start();System.out.println(Thread.currentThread().getName());}

此时我们发现打印结果如下，并且jvm已经结束

Lock接口

Synchronized 关键字

Synchronized 作用范围

Synchronized 是Java中的关键字，是一种同步锁，它修饰的对象有以下几种

1. 修饰一个代码块，被修饰代码块称为同步语句块，作用范围是大括号内的，作用的对象是调用这个代码块的对象 ，例如

public class Ticket {Object lock = new Object();public void blockMethod1(){synchronized (lock){for (int i = 0; i < 3; i++) {System.out.println("generalMethod1 excute"+i+" time");try {Thread.sleep(3000);} catch (InterruptedException e) {e.printStackTrace();}}}}}

2. 修饰一个方法，例如下面卖票例子中的卖票方法。虽然可以使用synchronized来定义方法，但是synchronized并不属于方法定义的一部分，因此，synchronized关键字不能被继承。如果在弗雷中的某个方法使用了synchronized关键字，而在子类中覆盖了这个方法，在子类中的这个方法默认情况下并不是同步的，而必须显示的在子类的方法中加上synchronized关键字才行。当然还可以在子类方法中调用父类被synchronized修饰的方法。

Synchronized 实现卖票例子

public class Ticket {//一共有一百张票private int num = 100;//卖票方法public synchronized void sell(){if (num > 0){num-- ;System.out.println(Thread.currentThread().getName() + "买了一张，余票还有："+num);}}public static void main(String[] args) {Ticket ticket = new Ticket();Runnable runnable = new Runnable() {@Overridepublic void run() {for (int i = 0; i < 50; i++) {ticket.sell();}}};new Thread(runnable, "t1").start();new Thread(runnable, "t2").start();new Thread(runnable, "t3").start();new Thread(runnable, "t4").start();}
}

最终打印结果如下

Lock接口

什么是Lock

java.util.concurrent.locks.Lock 是一个类似于synchronized 块的线程同步机制。但是 Lock比 synchronized 块更加灵活。Lock是个接口，既然是接口那就有实现类，如下图

• ReadLock
• ReadLockView
• WriteLock
• WriteLockView
• ReentrantLock （可重入锁）

Lock与synchronized的区别

1. synchronized是Java语言的关键字。Lock是一个接口，不是Java语言内置。
2. synchronized不需要用户去手动释放锁，发生异常或者线程结束时自动释放锁;Lock则必须要用户去手动释放锁，在finally中手动调用unlock方法去释放锁，如果没有主动释放锁，就有可能导致出现死锁现象。
3. Lock可以让等待锁的线程响应中断，而synchronized 则不行，synchronized会一直等待下去，不能够响应中断。（这是什么意思呢？怎么让线程响应中断？）
4. lock可以配置公平策略,实现线程按照先后顺序获取锁。
5. 提供了trylock方法 可以试图获取锁，获取到或获取不到时，返回不同的返回值 让程序可以灵活处理。也就是说我们在使用lock的时候，可以知道自己有没有获取到锁，灵活判断，而synchronized则不会，因为synchronized是自动完成的，我们无法知道他是否获取到了锁。
6. lock()和unlock()可以在不同的方法中执行,可以实现同一个线程在上一个方法中lock()在后续的其他方法中unlock(),比syncronized灵活的多。
7. 如果竞争的资源不是很激烈，则lock和synchronized的区别不大，但是如果竞争的资源很激烈，例如有非常多的线程在集中访问某一资源，则lock的性能要比synchronized大的多。

可重入锁（ReentrantLock）

Lock 和 synchronized 都是可重入锁的一种，只不过synchronized是一种隐式的可重入锁，Lock是一种显示的，这里的ReentrantLock只是Lock接口的一个实现，那么什么是可重入锁？
下面我们会详细介绍。

使用ReentrantLock实现卖票

public class LockTicket {private final ReentrantLock lock = new ReentrantLock();private Integer num = 100;//一百张票public void sell(){//加锁lock.lock();try {if (num > 0){num-- ;System.out.println(Thread.currentThread().getName() + "买了一张，余票还有："+num);}}finally {//释放锁，finally保证在代码执行过程中抛出异常也可以释放锁lock.unlock();}}public static void main(String[] args) {LockTicket lockTicket = new LockTicket();new Thread(() -> {for (int i = 0; i < 40; i++) {lockTicket.sell();}},"AA").start();new Thread(() -> {for (int i = 0; i < 40; i++) {lockTicket.sell();}},"BB").start();new Thread(() -> {for (int i = 0; i < 40; i++) {lockTicket.sell();}},"CC").start();}
}

最终结果：可以看出来在多次执行的过程中线程顺序不一样，执行次数也超过票数，但是依然有序并且保证了不会卖超。在这里有个问题，就是我们new Thread 之后的start方法会不会立即创建一个线程？答案是不一定，查看源码我们就会发现，这里创建线程最终是java代码调用了操作系统资源，如果系统空闲则会立即创建，如果系统繁忙则不一定会立即创建

读写锁

创建线程的多种方式

1. 继承Thread类并重写run方法：这种方式很少用，因为在Java中继承是一个比较XXX（不知道怎么形容，就是比较局限或者…）的操作
2. 实现Runnable接口，查看源码我们能发现这Runnable和Callable两个接口都标注了@FunctionalInterface注解，这说明这两个接口都是函数式接口，可以使用java8 lambda表达式；
3. Callable和Futura接口
4. 线程池
   参考: java创建线程的四种方式
   

线程间通信

什么是线程间通信

在上面的案例中我们提到，new Thread 线程是否会立即创建，并且按照创建的顺序执行？答案是否定的，那么我们如何让线程按照我们指定的顺序去执行？这就是线程间通信！

小例子

现在我们有这样一个需求，就是让两个线程分别对同一个初始值为0的变量做+1 和 -1 的操作，重复交替操作很多次。最终实现的效果就是A线程+1 ，变量值为1，B线程-1 变量值回到0 。最终变量的值就是10101010101010… A线程在变量值为0的时候做+1操作，在变量值不为0的时候等待，同理B线程在变量值为1的时候做-1操作，在变量值不为1的时候等待

我们都知道java中Object类（如下图），这个类中有一些方法，例如wait() notify() 等，我们就使用这个方法来分别使用synchronized和lock实现上面这个需求；

synchronized实现

//第一步 创建资源类
class Share{private int number = 0;//第二步创建资源操作方法//加1操作方法public synchronized void incr() throws InterruptedException {//判断if (number != 0){this.wait();}//干活number++;System.out.println(Thread.currentThread().getName() + "::" + number);//通知this.notifyAll();}//减一操作方法public synchronized void decr() throws InterruptedException {//判断if (number != 1){this.wait();}//干活number--;System.out.println(Thread.currentThread().getName() + "::" + number);//通知this.notifyAll();}
}public class ThreadDemo1 {//第三步创建多个线程调用资源操作方法public static void main(String[] args) {Share share = new Share();new Thread(() -> {for (int i = 1; i <= 10 ; i++) {try {share.incr();} catch (InterruptedException e) {e.printStackTrace();}}},"AA").start();new Thread(() -> {for (int i = 1; i <= 10 ; i++) {try {share.decr();} catch (InterruptedException e) {e.printStackTrace();}}},"BB").start();}
}

最终效果：

线程间虚假唤醒问题

在上面的例子中我们使用了两个线程AA和BB，那么如果我们再多加两个线程CC和DD，让CC加一，DD减一，最终会是什么效果呢？我们用伪代码举例并观察最终结果

//第一步 创建资源类
class Share{//... 同上
}
public class ThreadDemo1 {//第三步创建多个线程调用资源操作方法public static void main(String[] args) {//... 同上new Thread(() -> {//...},"AA").start();new Thread(() -> {//...},"BB").start();new Thread(() -> {//...},"CC").start();new Thread(() -> {//...},"DD").start();}
}

最终结果：通过多次执行下图我们可以发现，当增加两个线程后，结果和我们预期的并不相同，并没有出现我们预期的[AA：1] [BB：0] [CC：1] [DD：0] ... 那么是为什么呢？

我们可以看一下官方文档中对于Object类的wait() 方法的解释

在这段文字中有一句话对于某一个参数的版本，实现中断和虚假唤醒是可能的，而且此方法应始终在循环中使用，这其实就是线程的虚假唤醒导致的，wait()方法应该写在while循环中，并且wait() 方法会释放锁，下面我们用一个表格来描述一下发生这种现象的原因，如下，

我们发现一旦线程在AA和CC或者BB和DD之间重复切换执行，则会导致num大于1或者小于0的情况发生，其原因就是因为wait()方法，该方法的特点就是在那里睡着，唤醒之后就从哪里继续执行，例如上面例子中 这段代码，当wait之后，下次被唤醒就会直接从wait往下执行，不去执行if判断，这就是线程虚假唤醒导致最终线程执行结果异常的原因。

如何解决虚假唤醒

在上面的关于wait方法的官方文档中其实已经说明，将if判断改为while循环即可，原因就是每次wait之后，不论是什么时候唤醒，都要再执行一次while循环，此时就相当于while的条件就是if判断，我们修改之后再执行看看效果

Lock实现

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;//第一步创建资源类和资源操作方法
class Share1 {private int number = 0;private final Lock lock = new ReentrantLock();private final Condition condition = lock.newCondition();//+1操作public void incr() throws InterruptedException {//加锁lock.lock();try {//判断while (number != 0){condition.await();}//干活number++;System.out.println(Thread.currentThread().getName() + "::" + number);//通知condition.signalAll();}finally {//解锁lock.unlock();}}//-1操作public void decr() throws InterruptedException {//加锁lock.lock();try {//判断while (number != 1){condition.await();}//干活number--;System.out.println(Thread.currentThread().getName() + "::" + number);//通知condition.signalAll();}finally {//解锁lock.unlock();}}}public class ThreadDemo2 {public static void main(String[] args) {Share1 share = new Share1();new Thread(() -> {for (int i = 0; i < 10; i++) {try {share.incr();} catch (InterruptedException e) {e.printStackTrace();}}},"AA").start();new Thread(() -> {for (int i = 0; i < 10; i++) {try {share.decr();} catch (InterruptedException e) {e.printStackTrace();}}},"BB").start();new Thread(() -> {for (int i = 0; i < 10; i++) {try {share.incr();} catch (InterruptedException e) {e.printStackTrace();}}},"CC").start();new Thread(() -> {for (int i = 0; i < 10; i++) {try {share.decr();} catch (InterruptedException e) {e.printStackTrace();}}},"DD").start();}}

最终结果同样是正常，但是上面的例子我们发现了一个问题，就是我们所有的通知都是使用的All的方式，就是通知所有其他线程，那么可不可以只通知某个线程来执行当前方法呢？欲知后事如何，请看下一小节：线程间定制化通信！

线程间定制化通信

现在有个需求，就是有三个线程，我们需要实现的效果就是 AA线程打印2次，BB线程打印3次，CC线程打印4次，然后循环AA又打印2次，BB又3次，CC又4次… 循环执行5次
大概思路就是在资源类中定义一个变量，然后根据变量的变化来通知对应的线程执行方法
实现效果如下：

//创建资源类及资源类操作方法
class ShareResource{//标志位private int flag = 1;private final Lock lock = new ReentrantLock();private final Condition c1 = lock.newCondition();private final Condition c2 = lock.newCondition();private final Condition c3 = lock.newCondition();//创建操作资源的方法public void print2(int loop) throws InterruptedException {//上锁lock.lock();try {//判断while (flag != 1){c1.await();}//干活for (int i = 1; i <= 2; i++) {System.out.println(Thread.currentThread().getName() + "打印第" + i + "次 第" + loop + "轮打印");}//修改标志位，通知第二位线程flag = 2;c2.signal();}finally {//解锁lock.unlock();}}public void print3(int loop) throws InterruptedException {//上锁lock.lock();try {//判断while (flag != 2){c2.await();}//干活for (int i = 1; i <= 3; i++) {System.out.println(Thread.currentThread().getName() + "打印第" + i + "次 第" + loop + "轮打印");}//修改标志位，通知第二位线程flag = 3;c3.signal();}finally {//解锁lock.unlock();}}public void print4(int loop) throws InterruptedException {//上锁lock.lock();try {//判断while (flag != 3){c3.await();}//干活for (int i = 1; i <= 4; i++) {System.out.println(Thread.currentThread().getName() + "打印第" + i + "次 第" + loop + "轮打印");}//修改标志位，通知第二位线程flag = 1;c1.signal();}finally {//解锁lock.unlock();}}
}public class ThreadDemo3 {public static void main(String[] args) {ShareResource shareResource = new ShareResource();new Thread(() -> {for (int i = 1; i <= 5; i++) {try {shareResource.print2(i);} catch (InterruptedException e) {e.printStackTrace();}}},"AA").start();new Thread(() -> {for (int i = 1; i <= 5; i++) {try {shareResource.print3(i);} catch (InterruptedException e) {e.printStackTrace();}}},"BB").start();new Thread(() -> {for (int i = 1; i <= 5; i++) {try {shareResource.print4(i);} catch (InterruptedException e) {e.printStackTrace();}}},"CC").start();}
}

最终结果

使用 volatile 关键字

多线程编程步骤

综上，我们可以总结出来多线程编程的步骤

1. 第一步，创建资源类，例如上面卖票的Ticket，就是多线程需要竞争的资源类
2. 第二步，在资源类的操作方法中实现以下三步
   • ① 判断
   • ② 干活
   • ③ 通知
3. 创建多个线程调用资源类的操作方法
4. 防止虚假唤醒问题

集合线程安全

ArrayList

异常演示

看下面这段代码，在main方法中声明一个ArrayList集合，由于该集合是线程不安全的，因此在多线程环境中，一边放元素，一边取元素的时候，就会出现java.util.ConcurrentModificationException 异常，并发修改异常，

    public static void main(String[] args) {List list = new ArrayList<>();for (int i = 0; i < 50; i++) {new Thread(() -> {list.add(UUID.randomUUID().toString().substring(0,8));System.out.println(list);}, String.valueOf(i)).start();}}

最终结果

链接: 参考链接

解决方案1-Vector

Vector也是List接口的一个实现类，只不过它是线程安全的，只需要将上面代码中new ArrayList() 换成 new Vector() 即可

解决方案2-Collections

通过Collections工具类中提供的方法，返回一个线程安全的集合，解决方法也是与上面的类似，将代码中的new ArrayList() 换成 Collections.synchronizedList(new ArrayList<>()) 即可

解决方案3-CopyOnWriteArrayList

上面两种方法相对来说比较古老，我们用的也比较少，一般情况都是用JUC包中给我们提供的解决方法，也是就是CopyOnWriteArrayList 写时复制技术；

什么是写时复制技术

我们在使用CopyOnWriteArrayList的时候，首先它会允许并发读集合，如果有写入，则把当前集合复制一份，然后让单一线程写入复制的集合，等到写入完成之后，将两个集合做一个合并，再让其他线程读这个新集合，通过这种方式支持高并发。这样做的好处就是支持并发读，也照顾到了独立写，就不会存在上面的java.util.ConcurrentModificationException 异常。个人理解就是有一个读集合，这个时候大家都来读，读是不存在问题，这个时候如果A来写，然后A持有了添加方法的锁，其他写入线程智能等待A释放锁，等到A写完之后，原来读数据的线程读到的也就是新数组了，这个时候B再来获取锁，再接着写，再接着合并。
看一下源码：

• 首先声明可重入锁，加锁
• 然后获取到当前数组
• 拿到数组长度
• 将原来的数组加入到一个比原来数组长度大一的新数组
• 然后将元素放入新数组
• 然后将新数组设置到旧数组中
• 解锁

HashSet

public static void main(String[] args) throws InterruptedException {Set set = new HashSet<>();for (int i = 0; i < 30; i++) {new Thread(() -> {set.add(UUID.randomUUID().toString().substring(0,8));System.out.println(set);}, String.valueOf(i)).start();}Thread.sleep(2000);System.out.println("最后添加元素个数：" + set.size());}

与上面的代码一样，只不过是将ArrayList换成了HashSet，同样还是会出现上面的异常，解决方案也类似，是使用Set set = new CopyOnWriteArraySet();
在这里复习一下HashSet集合，HashSet的特点就是无序不重复，其底层原理就是使用的HashMap的Key，HashMap的key就是不重复，不重复的原理是计算了Key的HashCode。1.8之后的hashMap已经不是原来的数组+链表了，而是引入了红黑树，有兴趣可以看看 这位老铁的文章链接

HashMap

public static void main(String[] args) throws InterruptedException {Set set = new HashMap<>();for (int i = 0; i < 30; i++) {new Thread(() -> {set.add(UUID.randomUUID().toString().substring(0,8));System.out.println(set);}, String.valueOf(i)).start();}Thread.sleep(2000);System.out.println("最后添加元素个数：" + set.size());}

与上面的解决方案类似，将HashMap换成ConcurrentHashMap即可

多线程锁（synchronized线程8锁）

class Phone {public synchronized void sendMsg(){System.out.println("-----> 发送短信！");}public synchronized void sendEmail(){System.out.println("-----> 发送邮件");}public void sayHolle(){System.out.println("hello");}public void block(){synchronized (this){//do something...}}
}public class ThreadDemoArray {public static void main(String[] args) throws InterruptedException {Phone phone = new Phone();new Thread(() -> {phone.sendMsg();},"AA").start();Thread.sleep(100);new Thread(() -> {phone.sendEmail();},"BB").start();}}

首先看一下上面的代码，有一个类叫phone，里面有两个加了synchronized关键字的方法 sendMsg和sendEmail 还有一个普通方法，然后在main方法中创建两个线程并且让AA线程睡眠一百毫秒

• 第一种情况
  直接执行，结果：先打印发送短信，后打印发送邮件。原因：A线程执行sendMsg方法，持有当前对象的锁，其他线程只能等待AA线程释放锁之后才能执行。也就是说这个时候A线程持有的是当前对象this的锁。
• 第二种情况
  在发送短信方法中加TimeUnit.SECONDS.sleep(4); ，也就是说让AA线程睡四秒，最终打印的结果与上面一样，原因也是一样的，就是AA线程持有了当前对象的锁，其他线程需要等到AA线程释放锁才能执行其他操作。
  总结：在方法上加synchronized关键字，那么访问该方法的线程持有的是这个对象的锁，所以即使其他线程访问的是其他有synchronized关键字修饰的方法也同样需要等待释放锁
• 第三种情况

  public static void main(String[] args) throws InterruptedException {Phone phone = new Phone();new Thread(() -> {phone.sendMsg();},"AA").start();Thread.sleep(100);new Thread(() -> {phone.sayHello();},"BB").start();
  }
  

  这种情况的结果是先打印hello后打印发送短信，原因是普通方法不需要等待释放锁，直接执行打印，而发送短信的方法则需要睡四秒。
• 第四种情况

  public static void main(String[] args) throws InterruptedException {Phone phone = new Phone();Phone phone2 = new Phone();new Thread(() -> {phone.sendMsg();},"AA").start();Thread.sleep(100);new Thread(() -> {phone2 .sendEmail();},"BB").start();
  }
  

  这种情况是new 了两个对象，phone和phone2，然后分别在不同的线程中调用发送短信和发送邮件两个方法，最终的结果是先打印发送邮件后打印发送短信，原因是对这两个线程而言他们所持有的锁是不同对象的锁，也就是说是两把毫无关联的锁，并不需要彼此等待释放，因此发送邮件没有睡觉，直接打印，发送短信需要睡觉，所以后打印
• 第五种情况
  给发送短信和发送邮件分别加static关键字，也就是两个同步静态方法，然后new 一个phone对象在两个线程中分别执行发送短信和发送邮件，那么这个时候打印结果就是先打印发送短信，后打印发送邮件，因为一旦加了static关键字我们知道，这种方法是不需要new对象就可以直接调用，因为static修饰的方法或者变量是属于这个类，而不是这个类创建出来的对象，因此这个时候在执行发送短信的方法的时候锁住的是Phone的Class，而在调用发送邮件方法的时候同样是static修饰，同样需要Class的锁，因此在这种情况发送短信和发送邮件也是用的同一把锁，只不过这个锁是Class的锁，而不是对象的锁，因此也得等到AA执行完释放了Class的锁之后才能执行发送邮件。
• 第六种情况
  两部手机分别发送static修饰的短信和邮件方法，这中情况与上面的相同，这个时候不论你是有几个对象，这些对象都是由Class来的，并且执行static synchronized方法需要Class的锁，因此还是得等到AA释放锁才能继续执行发送邮件；
• 第七种情况
  一部手机分别执行由static修饰的发送短信和没有static修饰的发送邮件，这种情况先打印发送邮件，后打印发送短信，因为在这种情况就是两把锁了，发送短信是Class的锁，发送邮件是当前Phone对象也就是 this 的锁
• 第八种情况
  两部手机分别执行由static修饰的发送短信和非static修饰的发送邮件，这总情况和第七个一样，也是分别持有不同的锁

总结：对于同步方法，锁的是当前实例对象，也就是this，对于静态同步方法，锁的是当前类的Class对象，对于同步方法块，锁的是synchronized括号里配置的对象

同步方法块的意思就是例子中block方法里的synchronized括号里锁的对象，例如上面例子中synchronized(this) 中这个this就是当前对象，也就相当于是block方法上的synchronized。如果写法改为

public class Phone{private App app;public void block(){synchronized(app){//do something}}
}

则这种情况就相当于是所住了这个App对象，其他线程如果在调用时涉及到Phone中的app对象，则就需要等待其他涉及该对象的线程释放锁才能继续操作Phone对象中的这个app对象

公平锁和非公平锁

public class LockTicket {private final ReentrantLock lock = new ReentrantLock();private Integer num = 50;//一百张票public void sell(){//加锁lock.lock();try {if (num > 0){num-- ;System.out.println(Thread.currentThread().getName() + "买了一张，余票还有："+num);}}finally {//释放锁，finally保证在代码执行过程中抛出异常也可以释放锁lock.unlock();}}public static void main(String[] args) {LockTicket lockTicket = new LockTicket();new Thread(() -> {for (int i = 0; i < 40; i++) {lockTicket.sell();}},"AA").start();new Thread(() -> {for (int i = 0; i < 40; i++) {lockTicket.sell();}},"BB").start();new Thread(() -> {for (int i = 0; i < 40; i++) {lockTicket.sell();}},"CC").start();}
}

这段代码依然是上面使用lock实现卖票的例子，我们可以看到这里我们使用的是可重入锁ReentrantLock ，再看一下最终运行的效果如下图，我们可以看到这个AA线程从第一张票一直买到地10张票，直到它的次数用完了才到BB线程，而CC线程完全没用，这就是非公平锁，意思就是可能存在线程饿死的情况，也就是CC线程这种完全没用的情况，那么如何实现公平锁呢，只需要private final ReentrantLock lock = new ReentrantLock(true); 这样既可，在构造方法中传入参数true就可以了，我们看看效果如下图，可以看出来公平锁的情况三个线程都有参与。

那么公平锁与非公平锁的区别是什么？

• 非公平锁的效率高于公平锁，因为公平锁在抢占锁的时候会先判断一下锁有没有被占用
  看一下源码

	//可重入锁的构造器，里面判断是否公平public ReentrantLock(boolean fair) {sync = fair ? new FairSync() : new NonfairSync();}

可重入锁1（ReentrantLock）

什么是可重入锁

可重入锁又称递归锁，是指同一个线程在外层方法获取锁的时候，再进入该线程的内层方法会自动获取锁(前提是锁对象得是同一个对象)，不会因为之前已经获取过锁还没有释放而阻塞。

synchronized演示可重入锁

看代码
示例一：

public class ReentryLock {public static void main(String[] args) {Object o = new Object();new Thread(() -> {boolean b0 = Thread.holdsLock(o);//synchronized 使用 Thread.holdsLock()判断是否持有锁System.out.println(Thread.currentThread().getName() + "未进入同步，是否持有object的锁" + b0);synchronized (o){System.out.println(Thread.currentThread().getName() + "外层,是否持有object的锁" + Thread.holdsLock(o));synchronized (o){System.out.println(Thread.currentThread().getName() + "中层,是否持有object的锁"+ Thread.holdsLock(o));synchronized (o){System.out.println(Thread.currentThread().getName() + "内层,是否持有object的锁"+ Thread.holdsLock(o));}System.out.println(Thread.currentThread().getName() + "内层出来,是否持有object的锁"+ Thread.holdsLock(o));}System.out.println(Thread.currentThread().getName() + "中层出来,是否持有object的锁"+ Thread.holdsLock(o));}System.out.println(Thread.currentThread().getName() + "外层出来,是否持有object的锁"+ Thread.holdsLock(o));},"T1").start();}
}

最终结果

这个实例的意思就是当前线程只要拿到了最外层的锁，则里面的锁也可以任意进出，根据上面的线程八锁，我们可以看出来，AA线程访问了发送短信方法的时候，其他线程是无法访问发送邮件的方法的，但是AA线程是可以随时访问发送邮件的，这就是可重入锁的一种表现，因为AA线程此时持有锁，而锁的作用范围是当前对象，其他线程要访问发送邮件，首先要持有当前对象的锁

示例二：

class Message{public synchronized void sendA() throws InterruptedException {System.out.println(Thread.currentThread().getName() + "发送给A，时间：" + System.currentTimeMillis());Thread.sleep(5000);sendB();}public synchronized void sendB(){System.out.println(Thread.currentThread().getName() + "发送给B，时间：" + + System.currentTimeMillis());}
}
public class ReentryLock1 {public static void main(String[] args) throws InterruptedException {Message message = new Message();new Thread(() -> {try {System.out.println( Thread.currentThread().getName() + "开始发送，时间：" + System.currentTimeMillis());message.sendA();} catch (InterruptedException e) {e.printStackTrace();}},"T1").start();Thread.sleep(1000);new Thread(() -> {System.out.println(Thread.currentThread().getName() + "开始发送，时间：" + System.currentTimeMillis());message.sendB();},"T2").start();}
}

最终结果：

这段代码的意思就是main方法开始执行，创建message对象，创建T1线程，T1开始执行，打印开始发送和时间，同一时间进入sendA方法打印发送给A，然后T1线程开始睡觉5秒，一秒后创建T2线程并打印开始发送和时间，同一时间进入sendB方法，但是此刻message对象的锁被T1线程持有，T2线程只能等待T1释放锁，4秒后T1睡觉结束，执行sendB方法，执行结束释放锁，T2线程获取锁，执行sendB并打印。通过这个示例可以看出，T1线程持有了这个对象的锁，便可以任意访问该对象内的同步方法。那么问题来了，如果T1持有的不是对象锁呢？

看示例三

class Message{public synchronized void sendA() throws InterruptedException {System.out.println(Thread.currentThread().getName() + "发送给A，时间：" + System.currentTimeMillis());Thread.sleep(5000);sendB();}public synchronized void sendB(){System.out.println(Thread.currentThread().getName() + "发送给B，时间：" + + System.currentTimeMillis());}
}class Message2{private Message message = new Message();public void sendC() throws InterruptedException {System.out.println(Thread.currentThread().getName() + "发送给C，时间：" + + System.currentTimeMillis());synchronized (message){message.sendA();}}public synchronized void sendD(){System.out.println(Thread.currentThread().getName() + "发送给D，时间：" + + System.currentTimeMillis());message.sendB();}public Message getMessage(){return this.message;}}public class ReentryLock1 {public static void main(String[] args) throws InterruptedException {Message2 message2 = new Message2();new Thread(() -> {try {System.out.println( Thread.currentThread().getName() + "开始发送，时间：" + System.currentTimeMillis());message2.sendC();} catch (InterruptedException e) {e.printStackTrace();}},"T1").start();Thread.sleep(1000);new Thread(() -> {System.out.println(Thread.currentThread().getName() + "开始发送，时间：" + System.currentTimeMillis());try {message2.getMessage().sendA();} catch (InterruptedException e) {e.printStackTrace();}},"T2").start();}
}

最终结果：

我们来分析一下步骤，首先创建Message2对象，同时创建Message对象，然后线程T1开始创建执行，打印开始发送，同一时间调用Message2的非同步方法sendC并打印发送给C，然后锁住message属性调用message的sendA方法打印发送给A ，然后开始睡觉5秒，一秒后T2线程创建并打印开始发送，然后调用Message的sendA方法，但是此刻的sendA方法所在的对象message是被锁住的，并且持有锁的线程是T1，T2只能等待释放锁，4秒后T1睡觉结束，打印发送给B后释放锁，T2获取message的锁，调用sendA，然后睡5秒再调用sendB。基本上与上面的结论是一致的，锁的作用范围包括可重入锁的效果都能看出来。那么如果T2线程直接调用sendD方法会是什么效果呢？看一下最终结果

分析一下步骤，首先创建T1线程，打印T1开始发送，然后调用sendC方法，打印发送给C，然后进入同步方法调用sendA，打印T1发送给A，然后开始睡觉5秒，一秒后T2线程创建，打印T2开始发送，然后调用sendD方法，此时我们可以发现，T2直接调用了sendD，因为T1调用的sendC方法是非同步方法，它也没有锁住当前对象，它只是方法内部锁住了message对象，而非message2对象，如果锁住了message2对象，那么sendD方法是不能执行的。当T2打印完发送给D的时候，开始调用message的sendB方法的时候，这个时候就出现了争抢锁的问题，此时的message的锁还是在T1手中，所以只能等待T1释放锁。基本上上面的线程8锁已经将这几种情况都说明了。

Lock演示可重入锁

public class ReentryLock {public static void main(String[] args) {Lock lock = new ReentrantLock();new Thread(() -> {lock.lock();try {System.out.println(Thread.currentThread().getName() + "第一层");lock.lock();try {System.out.println(Thread.currentThread().getName() + "第二层");}finally {lock.unlock();}}finally {lock.unlock();}},"T1").start();}
}

最终结果：

这里可以看出来Lock与synchronized的效果一样，都是可重入锁的表现。那么如果我第二个锁不解锁呢？并且如果我有第二个线程要加锁呢？

public class ReentryLock {public static void main(String[] args) {Lock lock = new ReentrantLock();new Thread(() -> {lock.lock();try {System.out.println(Thread.currentThread().getName() + "第一层");lock.lock();try {System.out.println(Thread.currentThread().getName() + "第二层");}finally {//注释掉第二个解锁//lock.unlock();}}finally {lock.unlock();}},"T1").start();//第二个线程new Thread(()->{lock.lock();try {System.out.println(Thread.currentThread().getName() + "T2 开始执行");}finally {lock.unlock();}},"T2").start();}
}

最终结果

我们可以看到，这T1线程中还是正常执行的，但是T2线程却一直没有执行，因为没有释放锁它就无法获取到锁，所以就一直在等待，因此，加一把锁就要释放一把锁，不论是不是可重入，都要一对一的加锁释放锁

死锁

什么是死锁

两个或两个以上的线程在执行的过程中，因为争夺资源而导致的互相等待的现象，如果没有外力干涉则无法在继续执行，这种情况就是死锁。

如图，线程A持有锁A，试图获取锁B，线程B持有锁B，试图获取锁A，两个线程都在等待对方释放锁，这就产生了死锁
看代码

public static void main(String[] args) {Object a = new Object();Object b = new Object();new Thread(() -> {synchronized (a){System.out.println(Thread.currentThread().getName() + "持有锁A，试图获取锁B");try {TimeUnit.SECONDS.sleep(1);} catch (InterruptedException e) {e.printStackTrace();}synchronized (b){System.out.println(Thread.currentThread().getName() + "持有锁B");}}},"T1").start();//第二个线程new Thread(()->{synchronized (b) {System.out.println(Thread.currentThread().getName() + "持有锁A，试图获取锁B");synchronized (a) {System.out.println(Thread.currentThread().getName() + "持有锁B");}}},"T2").start();}

在这个例子中就是T1线程持有a锁，T2线程持有b锁，然后互相等待对方释放锁，于是死锁

验证是否是死锁

• jps -l
• jstack 进程号
  在命令窗口中输入jps -l 命令，如下图中第一行就是我们的代码位置，然后使用第二个命令jstack 15792 这里的15792 就是上面的jps命令中打出来的我们代码死锁的进程号，第二个命令中打出来的tid就是死锁的线程id
  
  

Callable接口

Callable接口与Runnable接口的区别就是Callable有返回值

	Callable