死锁

一、死锁

package lock;

/**
 * 死锁：多个线程互相拥有对方需要的资源，形成僵持
 */
public class DeadLock {
    public static void main(String[] args) {
        Makerup g1 = new Makerup(0, "灰姑凉");
        Makerup g2 = new Makerup(1, "白雪公主");

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

//口红
class Lipstick{

}

//镜子
class Mirror{

}

//化妆
class Makerup extends Thread {
    //需要的资源只有一份，用static来保证只要一份
    static Lipstick lipstick = new Lipstick();
    static Mirror mirror = new Mirror();

    int choice;  //选择
    String girlName;  //使用化妆品的人

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

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

    //化妆，互相持有对方的锁，就是需要i拿到对方的资源
    private void makeup() throws InterruptedException {
        if (choice == 0) {
            synchronized (lipstick) { //获得口红的锁
                System.out.println(this.girlName + "获得口红的锁");
                Thread.sleep(2000);

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

                synchronized (lipstick) {  //两秒钟后想要获得口红的锁
                    System.out.println(this.girlName + "获得口红的锁");
                }
            }
        }
    }
}

• 输出
  

锁中带锁，锁了口红之后得到镜子才能释放口红

• 解决办法

不要锁中带锁

package lock;

/**
 * 死锁：多个线程互相拥有对方需要的资源，形成僵持
 */
public class DeadLock {
    public static void main(String[] args) {
        Makerup g1 = new Makerup(0, "灰姑凉");
        Makerup g2 = new Makerup(1, "白雪公主");

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

//口红
class Lipstick{

}

//镜子
class Mirror{

}

//化妆
class Makerup extends Thread {
    //需要的资源只有一份，用static来保证只要一份
    static Lipstick lipstick = new Lipstick();
    static Mirror mirror = new Mirror();

    int choice;  //选择
    String girlName;  //使用化妆品的人

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

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

    //化妆，互相持有对方的锁，就是需要i拿到对方的资源
    private void makeup() throws InterruptedException {
        if (choice == 0) {
            synchronized (lipstick) { //获得口红的锁
                System.out.println(this.girlName + "获得口红的锁");
                Thread.sleep(2000);
            }

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

            synchronized (lipstick) {  //两秒钟后想要获得口红的锁
                System.out.println(this.girlName + "获得口红的锁");
            }
        }
    }
}

二、死锁的避免

产生死锁的四个必要条件

• 互斥条件：一个资源每次只能被一个进程使用
• 请求与保持条件：一个进程因请求资源而被阻塞时，对已获得的资源保持不放
• 不剥夺条件：进程已获得的资源，在未使用完之前，不能强行剥夺
• 循环等待条件：若干进程之间形成一种头尾相连的循环等待资源关系

我们只要破坏其中任意一个或者多个就能避免死锁的产生

三、Lock(锁)

• 从JDK5.0开始，Java提供了更强大的线程同步机制——通过显示定义同步锁对象来实现同步。同步锁使用Lock对象充当
• java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应先获得Lock对象
• ReentrantLock类实现了Lock，它拥有与synchronized相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是ReentrantLock,可以显式加锁、释放锁

package lock;

/**
 * 测试Lock锁
 */
public class LockTest {
    public static void main(String[] args) {
        LockTest2 lockTest2 = new LockTest2();

        new Thread(lockTest2).start();
        new Thread(lockTest2).start();
        new Thread(lockTest2).start();
    }
}

class LockTest2 implements Runnable {

    int ticketNums = 10;

    //定义一个lock锁
    

    @Override
    public void run() {
        while (true) {
            if (ticketNums > 0) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(ticketNums--);
            } else {
                break;
            }
        }
    }
}

不安全

• 加锁

package lock;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * 测试Lock锁
 */
public class LockTest {
    public static void main(String[] args) {
        LockTest2 lockTest2 = new LockTest2();

        new Thread(lockTest2).start();
        new Thread(lockTest2).start();
        new Thread(lockTest2).start();
    }
}

class LockTest2 implements Runnable {

    int ticketNums = 10;

    //定义一个lock锁
    private final ReentrantLock lock = new ReentrantLock();

    @Override
    public void run() {
        while (true) {
            try {
                lock.lock();  //加锁
                if (ticketNums > 0) {
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(ticketNums--);
                } else {
                    break;
                }
            } finally {
                //解锁
                lock.unlock();
            }

        }
    }
}

四、synchronized与Lock的对比

• Lock是显式锁（手动开启和关闭锁，别忘记关锁）；synchronized是隐式锁，出了作用域自动解锁
• Lock只有代码块锁，synchronized有代码块锁和方法锁
• 使用Lock锁，JVM将花费更少的时间来调度线程，性能更好。并且具有更好的扩展性（提供更多的子类）
• 优先使用顺序：
  • Lock>同步代码块(已经进了方法体，分配了相应的资源)>同步方法（在方法体之外）

本文地址：https://blog.csdn.net/qq_41799736/article/details/110197053