线程的死锁问题

死锁问题

1.定义：

在多线程编程中，两个或以上的线程因为资源抢占而造成的线程无限等待的问题
线程和锁的关系–一对多；一个线程可以拥有多把锁；而一把锁只能被一个线程 拥有
线程1已经有了锁A,线程2有了锁B
线程1继续去请求锁B，
线程2继续去请求锁A；
至此都请求不到，陷入等待

2.死锁代码

public class ThreadDemo20 {
    public static void main(String[] args) {
        Object lockA = new Object();
        Object lockB = new Object();
        Thread t1 =new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (lockA){
                    System.out.println("线程1获的了锁A");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("线程1等待获取锁B");
                    synchronized (lockB){
                        System.out.println("线程1获取到了锁B");
                    }
                }
            }
        },"t1");
        t1.start();
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (lockB){
                    System.out.println("线程2得到了锁B");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("线程2等待获取锁A");
                    synchronized (lockA){
                        System.out.println("线程2得到了锁A");
                    }
                }
            }
        },"t2");
        t2.start();
    }
}

总结死锁出现的条件

死锁的四个条件：

1. 互斥条件：一个资源在被占用之后，不能被其他线程占用
   2. 请求拥有–一个线程拥有了一把锁之后又去申请新的锁
   3. 不可剥夺–一个资源被一个线程拥有之后，如果这个线程不是放此资源，那么其他线程不能前置获得此资源
   4. 环路等待条件–多个线程在获取资源时形成了环形链

3. 解决死锁问题

只要解决四个条件中的任意一个即可;
1.互斥条件–不可更改的
2.请求拥有—可以修改
3.不可剥夺—不可更改
4.环路等待—可修改
因此我们可以从请求拥有和环路等待出发解决死锁问题：
环路等待条件是最容易解决的，
只要破坏环路即可，
让线程轮流持有两个锁即可：

public class ThreadDemo20 {
    public static void main(String[] args) {
        Object lockA = new Object();
        Object lockB = new Object();
        Thread t1 =new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (lockA){
                    System.out.println("线程1获的了锁A");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("线程1等待获取锁B");
                    synchronized (lockB){
                        System.out.println("线程1获取到了锁B");
                    }
                }
            }
        },"t1");
        t1.start();
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (lockA){
                    System.out.println("线程2得到了锁B");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("线程2等待获取锁A");
                    synchronized (lockB){
                        System.out.println("线程2得到了锁A");
                    }
                }
            }
        },"t2");
        t2.start();
    }
}