首页 > 基础资料 博客日记
Java中的死锁及其解决方案
2023-07-24 10:32:55基础资料围观240次
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
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类也是如此解决,改变两个线程获取锁的顺序
方式二,使用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();
}
}
本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若内容造成侵权/违法违规/事实不符,请联系邮箱:jacktools123@163.com进行投诉反馈,一经查实,立即删除!
标签: