java死锁举例分析

72次阅读
没有评论

共计 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 小编会继续努力为大家带来更多实用的文章!

正文完
 
丸趣
版权声明:本站原创文章,由 丸趣 2023-08-25发表,共计3407字。
转载说明:除特殊说明外本站除技术相关以外文章皆由网络搜集发布,转载请注明出处。
评论(没有评论)