励精图治---Concurrency---吞吐量、活跃性及死锁_concurrencyvisualizerconcurrencyvisualizerconcurre-优快云博客

本文深入探讨了死锁的概念、原因、危害，并提供了多种解决策略，包括超时、日志分析、轮询策略和线程优先级调整。通过具体代码示例展示了如何避免死锁，确保系统的稳定性和高吞吐量。

更新概念

所谓吞吐量跟活跃性：就是单位时间内，系统处理信息的数量，速度表现的结果。

所谓死锁：就是两个线程，我有你要的，你有我要的，互不相让，都等对方让出来，就死锁了。

分析情景

锁顺序死锁：所有的线程申请锁的顺序不一样，那么就存在一定概率发生死锁。

换言之，如果所有线程都以相同的顺序来获得锁，那么在程序中就不会出现锁顺序死锁问题。

危害

死锁，小应用当然没事。如果你是商业应用的软件呢。比如淘宝，特么一个锁一天可能要上百亿次被执行。要命了这

看范例1

public class EasyDead {
private final Object mALock = new Object();
private final Ojbect mBLock = new Object();

public void wantB(){
synchronized(mALock) {
synchronized(mBLock) {
doSomethings();
}
}
}

public void wantA(){
synchronized(mBLock) {
synchronized(mALock) {
doSomethings();
}
}
}
}

在多线程情况下，同时有线程执行了wantA跟wangB，那么就会导致死锁。

看范例2---百度上有说的银行转账面试题

public void trans(Account fromAccount, Account toAccount, int money) {
synchronized(fromAccount) {
synchronized(toAccount) {
if (fromAccount.getMoney() < money) {
throws new Exception();
} else {
fromAccount.del(money);
toAccount.add(money);
}
}
}
}

这里如果有两个账户，同时进行存钱和取钱操作。。。那么不就卡住了。看起来不会卡。其实依旧会卡。这个环路可以弄的大一点。

这两个范例，一个是静态直观可以发现。一个是动态的。

皆因锁顺序引起。而这里的加锁顺序还是可以改变的。这并不影响

那么静态是可以弄成一样的。动态的话，就需要用一定的规则：比如说hashCode。利用System.identityHashCode来计算。按照计算后的值排序。虽然依旧有一定的概率会一样。但毕竟是小概率事件。锁顺序死锁+小概率事件===极小概率事件。大幅降低也不错。

修改修改，看范例3

private final Object mLock = new Object();

public void trans(Account fromAccount, Account toAccount, int money) {
int from = System.identityHashCode(fromAccount);
int to = System.identityHashCode(toAccount);
if(from > to) {
synchronized(fromAccount) {
synchronized(toAccount) {
if (fromAccount.getMoney() < money) {
throws new Exception();
} else {
fromAccount.del(money);
toAccount.add(money);
}
}
}
} else if(from < to) {
synchronized(toAccount) {
synchronized(fromAccount) {
if (fromAccount.getMoney() < money) {
throws new Exception();
} else {
fromAccount.del(money);
toAccount.add(money);
}
}
}
} else {
synchronized(mLock) {//#多加一个私有锁。里头的锁顺序就不要紧了
synchronized(toAccount) {
synchronized(fromAccount) {
if (fromAccount.getMoney() < money) {
throws new Exception();
} else {
fromAccount.del(money);
toAccount.add(money);
}
}
}
}
}
}

这里排个序，然后针对一样的情况，再额外加个锁，吞吐也不会有大的影响。

范例4：对象间悄悄藏起来的死锁。

class A {
private final B b;
public A (B b) {
this.b = b;
}

public synchronized void tellB_toDoSomething() {
this.b.doB();
}
public synchronized void doA() {

}
}

class B {
private A a;
public B(){
a = new A(this);
}
public synchronized void telA_toDoSomething() {
this.a.doA();
}
public synchronized void doB() {

}
}