廖雪峰Java11多线程编程-2线程同步-3死锁

在多线程编程中，要执行synchronized块，必须首先获得指定对象的锁。

1.Java的线程锁是可重入的锁

    public void add(int m){
        synchronized (lock){
            this.value += m;
        }
    }

什么叫可重入的锁？

对同一个对象，同一个线程，可以多次获取它的锁，即同一把锁可以嵌套。

在add方法中，用synchronized获取了一个lock对象的锁，在synchronized代码块内部，调用another方法，可以再次获取到lock对象的锁。因为这是同一个线程对lock对象获取锁，所以它是一种可重入的锁。

    public void add(int m){
        synchronized (lock){
            this.value += m;
            another(m);
        }
    }
    public void addAnother(int m){
        synchronized (lock){
            this.another += m;
        }
    }
    //上述代码可以合并为
    public void add(int m){
        synchronized (lock){
            this.value += m;
            synchronized (lock){
                this.another += m;
            }
        }
    }

2. Java的线程还可以获取多个不同对象的锁

先用synchronized(lockA)获得lockA的锁，在用synchronized(lockB)获得lockB的锁。在释放锁的时候，会依次释放lockB的锁，再释放lockA的锁。

    public void add(int m){
        synchronized (lockA){//获取lockA的锁
            this.value += m;
            synchronized (LockB){//获取lockB的锁
                this.another += m;
            }//释放lockB的锁
        }//释放lockA的锁
    }

3.死锁

不同的线程获取多个不同对象的锁可能导致死锁

线程1和线程2分别执行。

线程1获取lockA的锁，线程2获得lockB的锁。

线程1执行语句，线程2执行语句。

线程1等待lockB的锁，线程2等待lockA的锁。这个时候，线程1和线程2会永远等待下去，谁也无法继续执行，就形成了死锁。

死锁形成的条件：

两个线程各自持有不同的锁。线程1持有A锁，线程2持有B锁。
两个线程各自试图获取对方的锁。线程1等待B锁，线程2等待A锁。
双方无限等待下去，导致死锁

死锁发生后：

没有任何机制能解除死锁
只能强制结束JVM进程

所以，我们在编写多线程程序时，必须要避免出现死锁。

如何避免死锁：线程获取锁的顺序要一致

4.示例

4.1 死锁

class ShareObject{
    final Object lockA = new Object();
    final Object lockB = new Object();
    int accountA = 1000;
    int accountB = 2000;
    public void a2b(int balance){ //a2b： acountA减， accountB加
        synchronized (lockA){
            accountA -= balance;
            synchronized (lockB){
                accountB += balance;
            }
        }
    }
    public void b2a(int balance){ //b2a：acountA加， accountB减
        synchronized (lockB){
            accountB -= balance;
            synchronized (lockA){
                accountA += balance;
            }
        }
    }
}
class AThread extends Thread{
    public void run(){
        for(int i=0;i<Main.LOOP;i++){
            Main.shared.a2b(1);
            if(i%100==0){
                System.out.println(".");
            }
        }
    }
}
class BThread extends Thread{
    public void run(){
        for(int i=0;i<Main.LOOP;i++){
            Main.shared.b2a(1);
            if(i%100==0){
                System.out.println(".");
            }
        }
    }
}
public class Main{
    final static int LOOP = 1000;
    public static ShareObject shared = new ShareObject();
    public static void main(String[] args) throws Exception{
        Thread t1 = new AThread();
        Thread t2 = new BThread();
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println("end");
    }
}

### 4.2 避免死锁
修改b2a()
“`#java
public void b2a(int balance){
synchronized (lockA){
accountA += balance;
synchronized (lockB){
accountB -= balance;
}
}
}
}
“`