Java中的死锁及其解决方案
在Java中，锁是很常见的一个工具，常见的用法就是在高并发场景下保证线程安全，但是使用不当也会造成死锁，给我们带来一些不必要的麻烦，本文分析死锁及其产生原因，并作出相应的解决方案。
死锁产生的四个必要条件
1）互斥条件：进程对所分配到的资源进行排他性控制，即在一段时间内某资源仅为一个进程所占有。此时若有其他进程请求该资源，则请求进程只能等待。
2）请求和保持条件：进程已经获得了至少一个资源，但又对其他资源发出请求，而该资源已被其他进程占有，此时该进程的请求被阻塞，但又对自己获得的资源保持不放。
3）不可剥夺条件：进程已获得的资源在未使用完毕之前，不可被其他进程强行剥夺，只能由自己释放。
4）环路等待条件：存在一种进程资源的循环等待链，链中每一个进程已获得的资源同时被 链中下一个进程所请求。
生活示例
死锁就好比两个人去过独木桥，小庞从桥左边出发，小贾从桥右边出发，然后到了桥中间，小庞要去右边，小贾要去左边，但两者都互不想让，最终只能在桥中间站着，造成死循环，谁也过不了河的结果。
对象A先持有锁1，然后对象B持有锁2，此时对象A要去获取锁2，但是锁2此时在对象B手里，对象B要去获取锁1，锁1在对象A手里，对象A，B互不相让，最终导致死链现象，出现死锁。
死锁代码
方式1，继承Runnable接口实现
package com.wwy.lock;
import java.util.concurrent.TimeUnit;
public class DieLock {
public static void main(String[] args) {
Object A = new Object();
Object B = new Object();
//线程1
/**
* ()->{} 此为jdk8新增的新特性 但要求目标接口只有一个抽象方法，而Runnable恰好符合此条件
*/
Thread thread1 = new Thread(()->{
synchronized (A){
System.out.println("线程1此时获取锁A");
try {
/**
* TimeUnit是一个时间工具类，更好的帮助我们定义休眠时间
*TimeUnit.DAYS //天
* TimeUnit.HOURS //小时
* TimeUnit.MINUTES //分钟
* TimeUnit.SECONDS //秒
* TimeUnit.MILLISECONDS //毫秒
* TimeUnit.NANOSECONDS //毫微秒
* TimeUnit.MICROSECONDS //微秒
*/
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
//对象A苏醒之后再去尝试获取锁2
synchronized (B){
System.out.println("线程1此时获取锁B");
}
}
});
thread1.start();
//线程2
Thread thread2 = new Thread(()->{
synchronized (B){
System.out.println("线程2此时获取锁B");
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
//对象A苏醒之后再去尝试获取锁2
synchronized (A){
System.out.println("线程2此时获取锁A");
}
}
});
thread2.start();
}
}
方式2，继承Thread类（不推荐使用）
package com.wwy.lock;
import java.util.concurrent.TimeUnit;
public class ThreadA extends Thread {
private Object A ;
private Object B ;
public Object getA() {
return A;
}
public void setA(Object a) {
A = a;
}
public Object getB() {
return B;
}
public void setB(Object b) {
B = b;
}
@Override
public void run() {
synchronized (A){
System.out.println("线程1此时获取锁A");
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (B){
System.out.println("线程1此时获取锁B");
}
}
}
}
package com.wwy.lock;
import java.util.concurrent.TimeUnit;
public class ThreadB extends Thread {
private Object A ;
private Object B ;
public Object getA() {
return A;
}
public void setA(Object a) {
A = a;
}
public Object getB() {
return B;
}
public void setB(Object b) {
B = b;
}
@Override
public void run() {
synchronized (B){
System.out.println("线程2此时获取锁B");
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (A){
System.out.println("线程2此时获取锁A");
}
}
}
}
package com.wwy.lock;
public class ThreadTest {
public static void main(String[] args) {
Object A = new Object();
Object B = new Object();
ThreadA t1 = new ThreadA();
ThreadB t2 = new ThreadB();
t1.setA(A);
t1.setB(B);
t2.setA(A);
t2.setB(B);
t1.start();
t2.start();
}
}
检测死锁
正常情况下应该打印四句话的，可此时程序一直在运行状态并且只打印了两句话，说明出现死锁现象，验证方法，可以去到我们jdk目录下的bin目录中的一个可视化界面查看
可以看到此处确实出现死锁现象
死锁解决方案
预防死锁的方式就是打破四个必要条件中的任意一个即可。
1）打破互斥条件：在系统里取消互斥。若资源不被一个进程独占使用，那么死锁是肯定不会发生的。但一般来说在所列的四个条件中，“互斥”条件是无法破坏的。因此，在死锁预防里主要是破坏其他几个必要条件，而不去涉及破坏“互斥”条件。。
2）打破请求和保持条件：采用资源预先分配策略，即进程运行前申请全部资源，满足则运行，不然就等待。
每个进程提出新的资源申请前，必须先释放它先前所占有的资源。
3）打破不可剥夺条件：当进程占有某些资源后又进一步申请其他资源而无法满足，则该进程必须释放它原来占有的资源。
4）打破环路等待条件：实现资源有序分配策略，将系统的所有资源统一编号，所有进程只能采用按序号递增的形式申请资源。
方案一，改变两个线程获取锁的顺序
让线程1和线程2的获取锁的顺序都是先获取锁A在获取锁B文章来源：https://www.toymoban.com/news/detail-470187.html
package com.wwy.lock;
import java.util.concurrent.TimeUnit;
public class DieLock {
public static void main(String[] args) {
Object A = new Object();
Object B = new Object();
//线程1
/**
* ()->{} 此为jdk8新增的新特性 但要求目标接口只有一个抽象方法，而Runnable恰好符合此条件
*/
Thread thread1 = new Thread(()->{
synchronized (A){
System.out.println("线程1此时获取锁A");
try {
/**
* TimeUnit是一个时间工具类，更好的帮助我们定义休眠时间
*TimeUnit.DAYS //天
* TimeUnit.HOURS //小时
* TimeUnit.MINUTES //分钟
* TimeUnit.SECONDS //秒
* TimeUnit.MILLISECONDS //毫秒
* TimeUnit.NANOSECONDS //毫微秒
* TimeUnit.MICROSECONDS //微秒
*/
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
//对象A苏醒之后再去尝试获取锁2
synchronized (B){
System.out.println("线程1此时获取锁B");
}
}
});
thread1.start();
//线程2
Thread thread2 = new Thread(()->{
synchronized (A){
System.out.println("线程2此时获取锁A");
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
//对象A苏醒之后再去尝试获取锁2
synchronized (B){
System.out.println("线程2此时获取锁B");
}
}
});
thread2.start();
}
}
继承Runnable类也是如此解决，改变两个线程获取锁的顺序文章来源地址https://www.toymoban.com/news/detail-470187.html
方式二，使用ReentrantLock来解决
package com.wwy.lock;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReentrantLock;
public class DieLock {
public static void main(String[] args) {
ReentrantLock lockA = new ReentrantLock();
ReentrantLock lockB = new ReentrantLock();
//线程1
/**
* ()->{} 此为jdk8新增的新特性 但要求目标接口只有一个抽象方法，而Runnable恰好符合此条件
*/
Thread thread1 = new Thread(()->{
while(true) {
if (lockA.tryLock()) {
System.out.println("线程1获取锁A");
try {
TimeUnit.SECONDS.sleep(1);
if (lockB.tryLock()) {
try {
System.out.println("线程1获取锁B");
} finally {
lockB.unlock();
System.out.println("线程1释放锁B");
break;
}
}
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
/**
* ReentrantLock与synchronized不同的是需要手动释放掉以获取的锁
*/
lockA.unlock();
System.out.println("线程1释放锁A");
}
}
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
thread1.start();
//线程2
Thread thread2 = new Thread(()->{
/**
* lock.lock()方法如果获取不到锁则禁用该线程，一直处于休眠状态，直至获取到锁为止
*/
lockB.lock();
System.out.println("线程2获取锁B");
try {
TimeUnit.SECONDS.sleep(1);
lockA.lock();
try {
System.out.println("线程2获取锁A");
}finally {
lockA.unlock();
System.out.println("线程2释放锁A");
}
} catch (InterruptedException e) {
e.printStackTrace();
}
finally {
/**
* ReentrantLock与synchronized不同的是需要手动释放掉以获取的锁
*/
lockB.unlock();
System.out.println("线程2释放锁B");
}
});
thread2.start();
}
}
到了这里，关于Java中的死锁及其解决方案的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！
