11死锁(同步方法块的嵌套）

死锁

死锁：多个线程互相抱着对方需要的资源，然后形成僵持

产生死锁的四个必要条件

1.互斥条件：一个资源每次只能被一个进程使用

2.请求与保持条件：一个进程因请求资源而堵塞时，对已获得的资源保持不放

3.不剥夺条件：进程已获得的资源，在未使用完之前，不能强行剥夺

4.循环等待条件：若干进程之间形成一种头尾相接的循环等待资源关系

上面的四个死锁必要条件，我们只需要想办法破除其中的任意一个或多个即可避免死锁发生

注意：为了确保使用的是同一个资源，该资源一定要被static修饰，否则就变成了多个线程使用不同的资源，此时同步块的嵌套将不会造成死锁

详细代码：

public class DeadLock {
    public static void main(String[] args) {
        Makeup g1 = new Makeup(0,"灰姑娘");
        Makeup g2 = new Makeup(1, "白雪公主");

        g1.start();
        g2.start();

    }
}


//口红
class Lipstick{
}

//镜子
class Mirror{
}

//化妆
class Makeup extends Thread{

    //需要的资源只有一份，使用static修饰代表资源只有一份
    private  static Lipstick lipstick = new Lipstick();
    private  static Mirror mirror = new Mirror();
     int choice;//选择
    String girlName;//使用化妆品的人

    public Makeup(int choice,String girlName){
        this.choice = choice;
        this.girlName = girlName;
    }

    @Override
    public void run() {
        //化妆
        try {
            makeup();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public void makeup() throws InterruptedException {
        if (choice==0){
            synchronized (lipstick){
                System.out.println(this.girlName+"获得口红的锁");
                Thread.sleep(1000);
                synchronized (mirror){//一秒钟后想获得镜子
                    System.out.println(this.girlName+"获得镜子的锁");
                }
            }



        }else {
            synchronized (mirror){
                System.out.println(this.girlName+"获得镜子的锁");
                Thread.sleep(2000);
                synchronized (lipstick){//2秒后想获得口红
                    System.out.println(this.girlName+"获得口红的锁");
                }
            }



        }


    }

}

以上代码会造成死锁问题，因为这段代码：

 public void makeup() throws InterruptedException {
        if (choice==0){
            synchronized (lipstick){
                System.out.println(this.girlName+"获得口红的锁");
                Thread.sleep(1000);
                synchronized (mirror){//一秒钟后想获得镜子
                    System.out.println(this.girlName+"获得镜子的锁");
                }
            }
        }else {
            synchronized (mirror){
                System.out.println(this.girlName+"获得镜子的锁");
                Thread.sleep(2000);
                synchronized (lipstick){//2秒后想获得口红
                    System.out.println(this.girlName+"获得口红的锁");
                }
            }
        }
    }

具有同步块的嵌套，也就是说两个线程都持有两把锁，每个线程的synchronize代码块不能被执行完，因为需要的资源被对方占用，所以不能释放锁，导致互相僵持

解决方案：取消同步块的嵌套，取消一个线程的同步块嵌套就能释放锁，建议取消两个，如下代码：

 public void makeup() throws InterruptedException {
        if (choice==0){
            synchronized (lipstick){
                System.out.println(this.girlName+"获得口红的锁");
                Thread.sleep(1000);
            }
            synchronized (mirror){//一秒钟后想获得镜子
                    System.out.println(this.girlName+"获得镜子的锁");
                }
        }else {
            synchronized (mirror){
                System.out.println(this.girlName+"获得镜子的锁");
                Thread.sleep(2000);
            }
             synchronized (lipstick){//2秒后想获得口红
                    System.out.println(this.girlName+"获得口红的锁");
                }
        }
    }