关于bootstrap:java安全编码指南之死锁dead-lock

39次阅读

共计 2993 个字符,预计需要花费 8 分钟才能阅读完成。

简介

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 循环中,如果不能获取到锁就循环遍历。

原文链接
本文为阿里云原创内容,未经容许不得转载。

正文完
 0