死锁

多个线程各自占有一些共享资源，并且互相等待其他线程占有的资源才能运行，而导致两个或者多个线程 都在等待对方释放资源，都停止执行的情形，某一个同步块同时拥有“两个以上对象的锁”时，就可能 会发生“死锁"的问题;

死锁是指多个线程在执行过程中，因为争夺资源而造成的一种互相等待的现象，导致这些线程都无法继续执行下去。

练习代码

package com.lock;/*
死锁
多个线程各自占有一些共享资源，并且互相等待其他线程占有的资源才能运行，而导致两个或者多个线程
都在等待对方释放资源，都停止执行的情形，某一个同步块同时拥有“两个以上对象的锁”时，就可能
会发生“死锁"的问题;*///死锁：多个线程互相抱着对方需要的资源，然后形成僵持
public class DeadLock {public static void main(String[] args) {Makeup g1 = new Makeup(0,"灰姑凉");Makeup g2 = new Makeup(0,"白雪公主");g1.start();g2.start();}
}//口红（Lipstick）
class Lipstick{}//镜子（Mirror）
class Mirror{}//化妆（Makeup）
class Makeup extends Thread{//需要的资源只有一份，用static来抱着只有一份static Lipstick lipstick = new Lipstick();static Mirror mirror = new Mirror();int choice;//选择String girlName;//使用化妆品的人Makeup(int choice,String girlName){this.choice = choice;this.girlName = girlName;}@Overridepublic void run() {//化妆try {makeup();} catch (InterruptedException e) {e.printStackTrace();}}//化妆，互相持有对方的锁,就是需要拿到对方的资源private void makeup() throws InterruptedException {if (choice == 0) {synchronized (lipstick) {//获得口红的锁System.out.println(this.girlName + "获得口红的锁");Thread.sleep(1000);synchronized (mirror){//1s钟后想获得镜子 的锁System.out.println(this.girlName + "获得镜子的锁");}}}else {synchronized (mirror) {//获得镜子的锁System.out.println(this.girlName + "获得镜子的锁");Thread.sleep(2000);synchronized (lipstick){//2s钟后想获得口红 的锁System.out.println(this.girlName + "获得口红的锁");}}}}
}

代码结构

1. DeadLock类：这是主类，包含main方法，用于启动两个线程。

2. Lipstick类和Mirror类：这两个类分别代表口红和镜子，是共享资源。

3. Makeup类：继承自Thread类，表示一个化妆的线程。每个线程代表一个女孩，她们需要使用口红和镜子来化妆。

代码逻辑

1. 共享资源：

   • Lipstick和Mirror是两个共享资源，分别代表口红和镜子。

   • 这两个资源被声明为static，确保它们在所有Makeup实例之间共享。

2. Makeup类：

   • choice：表示女孩的选择，决定她们先获取哪个资源。

   • girlName：表示女孩的名字。

   • run()方法：线程启动后执行的方法，调用makeup()方法。

   • makeup()方法：模拟化妆过程，尝试获取口红和镜子的锁。

3. 死锁的产生：

   • 如果choice为0，线程会先获取口红的锁，然后尝试获取镜子的锁。

   • 如果choice为1，线程会先获取镜子的锁，然后尝试获取口红的锁。

   • 由于两个线程的执行顺序不同，可能会导致以下情况：

     • 线程1（灰姑凉）持有口红的锁，等待镜子的锁。

     • 线程2（白雪公主）持有镜子的锁，等待口红的锁。

   • 这样，两个线程互相等待对方释放资源，导致死锁。

代码执行流程

1. 启动线程：

   • g1和g2两个线程分别启动，代表灰姑凉和白雪公主。

   • g1的choice为0，g2的choice为1。

2. 线程执行：

   • g1先获取口红的锁，然后尝试获取镜子的锁。

   • g2先获取镜子的锁，然后尝试获取口红的锁。

3. 死锁发生：

   • g1持有口红的锁，等待g2释放镜子的锁。

   • g2持有镜子的锁，等待g1释放口红的锁。

   • 两个线程都无法继续执行，形成死锁。

如何避免死锁

1. 锁的顺序：确保所有线程以相同的顺序获取锁。例如，所有线程都先获取口红的锁，再获取镜子的锁。

2. 超时机制：在获取锁时设置超时时间，如果超时则释放已持有的锁并重试。

3. 死锁检测：使用工具或算法检测死锁，并采取相应措施解除死锁。

优化后代码

package com.lock;/*
死锁
多个线程各自占有一些共享资源，并且互相等待其他线程占有的资源才能运行，而导致两个或者多个线程
都在等待对方释放资源，都停止执行的情形，某一个同步块同时拥有“两个以上对象的锁”时，就可能
会发生“死锁"的问题;死锁避免方法
产生死锁的四个必要条件
1.互斥条件:一个资源每次只能被一个进程使用；
2.请求与保持条件:一个进程因请求资源而阻塞时，对已获得的资源保持不放；
3.不剥夺条件：进程已获得的资源，在未使用完之前，不能强行剥夺；
4，循环等待条件：若干进程之间形成一种头尾相接的循环等待资源关系。只要想办法破其中的任意一个或多个条件就可以避免死锁发生*///死锁：多个线程互相抱着对方需要的资源，然后形成僵持
public class DeadLock {public static void main(String[] args) {Makeup g1 = new Makeup(0,"灰姑凉");Makeup g2 = new Makeup(0,"白雪公主");g1.start();g2.start();}
}//口红（Lipstick）
class Lipstick{}//镜子（Mirror）
class Mirror{}//化妆（Makeup）
class Makeup extends Thread{//需要的资源只有一份，用static来抱着只有一份static Lipstick lipstick = new Lipstick();static Mirror mirror = new Mirror();int choice;//选择String girlName;//使用化妆品的人Makeup(int choice,String girlName){this.choice = choice;this.girlName = girlName;}@Overridepublic void run() {//化妆try {makeup();} catch (InterruptedException e) {e.printStackTrace();}}//化妆，互相持有对方的锁,就是需要拿到对方的资源private void makeup() throws InterruptedException {if (choice == 0) {synchronized (lipstick) {//获得口红的锁System.out.println(this.girlName + "获得口红的锁");Thread.sleep(1000);}synchronized (mirror){//1s钟后想获得镜子 的锁System.out.println(this.girlName + "获得镜子的锁");}}else {synchronized (mirror) {//获得镜子的锁System.out.println(this.girlName + "获得镜子的锁");Thread.sleep(2000);}synchronized (lipstick){//2s钟后想获得口红 的锁System.out.println(this.girlName + "获得口红的锁");}}}
}

修改后的代码分析

关键修改点

1. 锁的嵌套被移除：

   • 在原始代码中，synchronized块是嵌套的，即一个线程在持有第一个锁的情况下尝试获取第二个锁。

   • 在修改后的代码中，synchronized块是分开的，线程在释放第一个锁之后才会尝试获取第二个锁。

2. 锁的获取顺序：

   • 修改后的代码中，线程不会同时持有两个锁，而是先释放一个锁，再尝试获取另一个锁。

   • 这样就不会出现两个线程互相等待对方释放锁的情况。

---

修改后的代码执行逻辑

线程1（灰姑凉）的执行流程：

1. 获取lipstick的锁。

2. 打印“灰姑凉获得口红的锁”。

3. 释放lipstick的锁。

4. 获取mirror的锁。

5. 打印“灰姑凉获得镜子的锁”。

6. 释放mirror的锁。

线程2（白雪公主）的执行流程：

1. 获取mirror的锁。

2. 打印“白雪公主获得镜子的锁”。

3. 释放mirror的锁。

4. 获取lipstick的锁。

5. 打印“白雪公主获得口红的锁”。

6. 释放lipstick的锁。

---

为什么避免了死锁？

1. 锁的释放：

   • 每个线程在获取一个锁后，会先释放它，再尝试获取另一个锁。

   • 这样就不会出现一个线程持有lipstick的锁并等待mirror的锁，而另一个线程持有mirror的锁并等待lipstick的锁的情况。

2. 没有互相等待：

   • 线程1和线程2不会同时持有对方需要的锁，因此不会形成互相等待的僵局。

Lock锁 

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

以下代码演示了如何使用ReentrantLock来实现线程同步，确保多个线程安全地访问共享资源。ReentrantLock是Java中提供的一种显式锁机制，相比于synchronized关键字，它提供了更灵活的锁控制方式。

package com.lock;import java.util.concurrent.locks.ReentrantLock;/*
Lock（锁）
1、JDK5.0开始，Java提供了更强大的线程同步机制--通过显式定义同步锁对象来实现同步。
同步锁使用Lock对象充当
2、java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。
锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应先获得Lock对象
ReentrantLoc类（可重入锁）实现了Lock，它拥有与synchronized相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是
ReentrantLock，可以显式加锁、释放锁*/
//测试lock锁
public class TestLock {public static void main(String[] args) {TestLock2 testLock2 = new TestLock2();new Thread(testLock2).start();new Thread(testLock2).start();new Thread(testLock2).start();}
}class TestLock2 implements Runnable{int ticketNums = 10;//定义lock锁private final ReentrantLock lock = new ReentrantLock();@Overridepublic 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();}}}
}

代码结构

1. TestLock类：

   • 这是主类，包含main方法，用于启动多个线程。

   • 创建了一个TestLock2对象，并启动三个线程来执行该对象的run方法。

2. TestLock2类：

   • 实现了Runnable接口，表示一个任务，可以被多个线程执行。

   • 包含一个共享资源ticketNums（票数），多个线程会竞争访问和修改这个资源。

   • 使用ReentrantLock来确保对ticketNums的访问是线程安全的。

---

代码逻辑

1. 共享资源

• ticketNums：表示剩余的票数，初始值为10。

• 多个线程会同时访问和修改ticketNums，因此需要确保线程安全。

2. ReentrantLock

• ReentrantLock是一个可重入锁，允许线程多次获取同一把锁。

• 通过lock()方法加锁，通过unlock()方法解锁。

• 使用try-finally块确保锁一定会被释放，避免死锁。

3. 线程执行逻辑

• 每个线程执行TestLock2的run方法。

• 在while (true)循环中，线程不断尝试获取锁并访问共享资源ticketNums。

• 如果ticketNums > 0，线程会休眠1秒（模拟耗时操作），然后打印并减少ticketNums的值。

• 如果ticketNums <= 0，线程退出循环，任务结束。

---

代码执行流程

1. 启动线程：

   • 在main方法中，创建了一个TestLock2对象，并启动三个线程。

   • 这三个线程会并发执行TestLock2的run方法。

2. 线程竞争锁：

   • 每个线程在执行run方法时，会先调用lock.lock()尝试获取锁。

   • 只有一个线程能成功获取锁，其他线程会被阻塞，直到锁被释放。

3. 访问共享资源：

   • 获取锁的线程会检查ticketNums的值。

   • 如果ticketNums > 0，线程会休眠1秒，然后打印ticketNums的值并将其减1。

   • 如果ticketNums <= 0，线程会退出循环。

4. 释放锁：

   • 线程在完成对共享资源的操作后，会调用lock.unlock()释放锁。

   • 其他被阻塞的线程会竞争获取锁，继续执行。

5. 任务结束：

   • 当ticketNums的值减少到0时，所有线程都会退出循环，任务结束。

关键点

1. ReentrantLock的作用：

   • 确保多个线程对共享资源ticketNums的访问是互斥的，避免数据竞争。

   • 相比于synchronized，ReentrantLock提供了更灵活的锁控制，例如可中断锁、超时锁等。

2. try-finally的作用：

   • 在try块中加锁，在finally块中解锁，确保锁一定会被释放，避免死锁。

3. 线程安全：

   • 通过ReentrantLock实现了对共享资源的线程安全访问。

---

改进建议

1. 锁的粒度：

   • 当前代码中，锁的粒度较大（整个while循环都在锁内），可能会影响并发性能。可以根据实际需求调整锁的粒度。

2. 公平锁：

   • ReentrantLock默认是非公平锁，可以通过构造函数new ReentrantLock(true)创建公平锁，确保线程按顺序获取锁。

3. 锁的可中断性：

   • ReentrantLock支持可中断的锁获取（lockInterruptibly()），可以在线程等待锁时响应中断。

改进后代码：

package com.lock;import java.util.concurrent.locks.ReentrantLock;/*
改进后的TestLock示例：
1. 缩小锁的粒度，只对共享资源的访问和修改加锁。
2. 使用公平锁，确保线程按顺序获取锁。
3. 优化代码结构，提高可读性和可维护性。
*/public class TestLock {public static void main(String[] args) {TestLock2 testLock2 = new TestLock2();// 启动多个线程new Thread(testLock2, "线程1").start();new Thread(testLock2, "线程2").start();new Thread(testLock2, "线程3").start();}
}class TestLock2 implements Runnable {private int ticketNums = 10; // 共享资源，表示剩余的票数// 定义公平锁private final ReentrantLock lock = new ReentrantLock(true);@Overridepublic void run() {while (true) {// 尝试获取锁lock.lock();try {if (ticketNums > 0) {// 模拟耗时操作try {Thread.sleep(100);} catch (InterruptedException e) {e.printStackTrace();}// 打印当前线程名和剩余的票数System.out.println(Thread.currentThread().getName() + " 售出票号：" + ticketNums--);} else {// 票已售完，退出循环break;}} finally {// 释放锁lock.unlock();}// 模拟线程切换，增加并发性try {Thread.sleep(10);} catch (InterruptedException e) {e.printStackTrace();}}}
}

synchronized 与Lock的对比

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