共计 3407 个字符,预计需要花费 9 分钟才能阅读完成。
这篇文章主要介绍“java 死锁举例分析”,在日常操作中,相信很多人在 java 死锁举例分析问题上存在疑惑,丸趣 TV 小编查阅了各式资料,整理出简单好用的操作方法,希望对大家解答”java 死锁举例分析”的疑惑有所帮助!接下来,请跟着丸趣 TV 小编一起来学习吧!
简介
java 中为了保证共享数据的安全性,我们引入了锁的机制。有了锁就有可能产生死锁。
死锁的原因就是多个线程锁住了对方所需要的资源,然后现有的资源又没有释放,从而导致循环等待的情况。
通常来说如果不同的线程对加锁和释放锁的顺序不一致的话,就很有可能产生死锁。
不同的加锁顺序
我们来看一个不同加锁顺序的例子:
public class DiffLockOrder {
private int amount;
public DiffLockOrder(int amount){
this.amount=amount;
}
public void transfer(DiffLockOrder target,int transferAmount){ synchronized (this){ synchronized (target){ if(amount transferAmount){
System.out.println( 余额不足! }else{
amount=amount-transferAmount;
target.amount=target.amount+transferAmount;
}
}
}
}
}
上面的例子中,我们模拟一个转账的过程,amount 用来表示用户余额。transfer 用来将当前账号的一部分金额转移到目标对象中。
为了保证在 transfer 的过程中,两个账户不被别人修改,我们使用了两个 synchronized 关键字,分别把 transfer 对象和目标对象进行锁定。
看起来好像没问题,但是我们没有考虑在调用的过程中,transfer 的顺序是可以发生变化的:
DiffLockOrder account1 = new DiffLockOrder(1000);
DiffLockOrder account2 = new DiffLockOrder(500);
Runnable target1= ()- account1.transfer(account2,200);
Runnable target2= ()- account2.transfer(account1,100);
new Thread(target1).start();
new Thread(target2).start();
上面的例子中,我们定义了两个 account,然后两个账户互相转账,最后很有可能导致互相锁定,最后产生死锁。
使用 private 类变量
使用两个 sync 会有顺序的问题,那么有没有办法只是用一个 sync 就可以在所有的实例中同步呢?
有的,我们可以使用 private 的类变量,因为类变量是在所有实例中共享的,这样一次 sync 就够了:
public class LockWithPrivateStatic {
private int amount;
private static final Object lock = new Object();
public LockWithPrivateStatic(int amount){
this.amount=amount;
}
public void transfer(LockWithPrivateStatic target, int transferAmount){ synchronized (lock) { if (amount transferAmount) {
System.out.println( 余额不足! } else {
amount = amount - transferAmount;
target.amount = target.amount + transferAmount;
}
}
}
}
使用相同的 Order
我们产生死锁的原因是无法控制上锁的顺序,如果我们能够控制上锁的顺序,是不是就不会产生死锁了呢?
带着这个思路,我们给对象再加上一个 id 字段:
private final long id; // 唯一 ID,用来排序
private static final AtomicLong nextID = new AtomicLong(0); // 用来生成 ID
public DiffLockWithOrder(int amount){
this.amount=amount;
this.id = nextID.getAndIncrement();
}
在初始化对象的时候,我们使用 static 的 AtomicLong 类来为每个对象生成唯一的 ID。
在做 transfer 的时候,我们先比较两个对象的 ID 大小,然后根据 ID 进行排序,最后安装顺序进行加锁。这样就能够保证顺序,从而避免死锁。
public void transfer(DiffLockWithOrder target, int transferAmount){
DiffLockWithOrder fist, second;
if (compareTo(target) 0) {
fist = this;
second = target;
} else {
fist = target;
second = this;
}
synchronized (fist){ synchronized (second){ if(amount transferAmount){
System.out.println( 余额不足! }else{
amount=amount-transferAmount;
target.amount=target.amount+transferAmount;
}
}
}
}
释放掉已占有的锁
死锁是互相请求对方占用的锁,但是对方的锁一直没有释放,我们考虑一下,如果获取不到锁的时候,自动释放已占用的锁是不是也可以解决死锁的问题呢?
因为 ReentrantLock 有一个 tryLock() 方法,我们可以使用这个方法来判断是否能够获取到锁,获取不到就释放已占有的锁。
我们使用 ReentrantLock 来完成这个例子:
public class DiffLockWithReentrantLock {
private int amount;
private final Lock lock = new ReentrantLock();
public DiffLockWithReentrantLock(int amount){
this.amount=amount;
}
private void transfer(DiffLockWithReentrantLock target, int transferAmount)
throws InterruptedException { while (true) { if (this.lock.tryLock()) {
try { if (target.lock.tryLock()) {
try { if(amount transferAmount){
System.out.println( 余额不足! }else{
amount=amount-transferAmount;
target.amount=target.amount+transferAmount;
}
break;
} finally { target.lock.unlock();
}
}
} finally { this.lock.unlock();
}
}
// 随机 sleep 一定的时间,保证可以释放掉锁
Thread.sleep(1000+new Random(1000L).nextInt(1000));
}
}
}
我们把两个 tryLock 方法在 while 循环中,如果不能获取到锁就循环遍历。
到此,关于“java 死锁举例分析”的学习就结束了,希望能够解决大家的疑惑。理论与实践的搭配能更好的帮助大家学习,快去试试吧!若想继续学习更多相关知识,请继续关注丸趣 TV 网站,丸趣 TV 小编会继续努力为大家带来更多实用的文章!