Java中高级高并发与多线程系列（五）：线程的 synchronized 同步与死锁

首先声明，本系列文章分享都是我自己的学习理解以后，原创手敲，可能包含错误的观点和理解，仅供参考，如遇错误的地方欢迎指正。

了解过多线程的同学肯定听说过 synchronized 这个关键词，我们先用一个错误的案例来引出不使用 synchronized 引发的问题，然后再使用 synchronized 解决问题，然后再由 synchronized 引出死锁问题。本篇先介绍不做更深入的研究，后面文章会慢慢深入。

多线程系列全部演示代码公开在：https://github.com/renfei/demo/tree/master/java/ConcurrentDemo

引出问题

我们先使用错误的案例引出问题，在多线程环境中不使用 synchronized 会发生什么？我们写程序模拟多个摊贩售卖苹果的情况，我们先定义一个售卖苹果的程序，一共有 10 个苹果：

/**
* 售卖苹果的线程A，这是一个错误的演示，引出存在的问题
*/
class SaleAppleA implements Runnable {
// 一共有 10 个苹果
private int apple = 10;
@Override
public void run() {
while (true) {
if (this.apple > 0) {
try {
// 模拟延迟，在真实场景中这里可能是网络延迟或者业务逻辑执行延迟
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("线程 " + Thread.currentThread().getName() + " 售卖了苹果编号：" + this.apple--);
} else {
System.out.println("线程 " + Thread.currentThread().getName() + " 售卖结束，关门了");
break;
}
}
}
}

然后让三个摊贩渠道去售卖：

SaleAppleA saleAppleA = new SaleAppleA();
new Thread(saleAppleA, "摊贩A-A").start();
new Thread(saleAppleA, "摊贩A-B").start();
new Thread(saleAppleA, "摊贩A-C").start();

我们会看到，同一个苹果编号可能被多个摊贩重复销售，甚至有的已经关门了，但有的还在售卖，这显然是不符合正常情况的，应该一个苹果只能被销售一次，并且销售为空时应都关门，而不是有的关了有的还在销售。

这个就是多线程环境中的同步问题，多个摊贩拿走苹果的时候，其他摊贩并不知道，还能拿走同一个苹果，所以我们就需要一种机制保证苹果拿走就是拿走了，而不是可以被多次拿走同一个苹果。

线程同步

为了解决上面引出的问题，Java 为我们提供了一个 synchronized 关键字，这里先不做深入的研究，后面会专门写一篇原子性内置锁 synchronized。

我们新写一个SaleAppleB，在销售方法上，我们只增加了 synchronized 关键字：

/**
* 售卖苹果的线程B，加入同步锁机制
*/
class SaleAppleB implements Runnable {
// 一共有 10 个苹果
private int apple = 10;
private synchronized boolean sale() {
if (this.apple > 0) {
try {
// 模拟延迟，在真实场景中这里可能是网络延迟或者业务逻辑执行延迟
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("线程 " + Thread.currentThread().getName() + " 售卖了苹果编号：" + this.apple--);
return false;
} else {
System.out.println("线程 " + Thread.currentThread().getName() + " 售卖结束，关门了");
return true;
}
}
@Override
public void run() {
while (true) {
if (this.sale()) {
break;
}
}
}
}

然后准备几个摊贩，再试试：

SaleAppleB saleAppleB = new SaleAppleB();
new Thread(saleAppleB, "摊贩B-A").start();
new Thread(saleAppleB, "摊贩B-B").start();
new Thread(saleAppleB, "摊贩B-C").start();

完整演示代码公开在：https://github.com/renfei/demo/blob/master/java/ConcurrentDemo/src/main/java/net/renfei/demo/concurrent/ThreadSynchronizationDemo.java

这个时候就非常和谐了，不会出现重复销售同一个苹果，因为加了 synchronized 关键字以后，同一个时间只有一个进程可以进入销售方法，所以就正常了。

synchronized 是一种比较重的锁，当有进程进入 synchronized 方法的时候，整个 SaleAppleB 都会被锁住，一次只能允许一个进程进来，这个时候使用不当还会引发另一个问题，就是死锁。

线程死锁

同样我们先演示个死锁给大家看看，我想出来的案例是买苹果的案例，我们先定义两个资源类，Money 钱资源和Apple苹果资源，然后他俩的逻辑是这样的：

钱：先给我苹果，我就给你钱

苹果：先给我钱，我就给你苹果

实例代码：

/**
* 线程间，资源互持，死锁演示
*
* @author renfei
*/
public class DeadlockDemo implements Runnable {
private Money money = new Money();
private Apple apple = new Apple();
public static void main(String[] args) {
new DeadlockDemo();
}
/**
* main 线程实例化的时候，占有钱对象，需要拿到苹果，才能付钱
*/
public DeadlockDemo() {
new Thread(this).start();
money.buy(apple);
}
/**
* 子线程占有苹果，需要拿到钱，才能销售苹果
*/
@Override
public void run() {
apple.sale(money);
}
}
/**
* 钱的资源
*/
class Money {
/**
* 买苹果
*
* @param apple 苹果
*/
public synchronized void buy(Apple apple) {
System.out.println("线程 " + Thread.currentThread().getName() + "：给我苹果。我就给你钱");
apple.ok();
}
public synchronized void ok() {
System.out.println("线程 " + Thread.currentThread().getName() + "：购买苹果成功。");
}
}
/**
* 苹果资源
*/
class Apple {
/**
* 销售苹果
*
* @param money 钱
*/
public synchronized void sale(Money money) {
System.out.println("线程 " + Thread.currentThread().getName() + "：给我钱。我就给你苹果");
money.ok();
}
public synchronized void ok() {
System.out.println("线程 " + Thread.currentThread().getName() + "：销售苹果成功。");
}
}

完整代码公开在：https://github.com/renfei/demo/blob/master/java/ConcurrentDemo/src/main/java/net/renfei/demo/concurrent/DeadlockDemo.java

如果运行的话，就可以看出，程序卡在这里了，钱在等苹果释放资源，苹果在等钱释放资源，死锁就是两个资源相互持有各自所需的资源，就会导致一直在这里等着。

其实死锁不一定是两个资源相互死锁，只要多个资源形成一个环形的持有关系，就可以形成死锁，所以打破死锁只要破坏环形持有关系就可以。