线程死锁

线程死锁

安全性和活跃度通常是相互制约的，虽然可以通过开辟一定量的线程来提高活跃度，但是用来保证多线程安全的锁也可能引起锁顺序死锁问题（lock-ordering deadlock）。类似，我们使用线程池和信号量来约束资源的使用，但是也可能存在资源死锁(resource deadlock)。Java程序不能从死锁中恢复，所以能够避免死锁对于程序的设计十分重要。

死锁

哲学家就餐是多线程中很经典的问题，它就存在死锁风险。五位哲学家都抓住右边的叉子，同时等待左边的叉子而不放弃右边的叉子时，那么任意一位哲学家都吃不到面，从而饿死。在Executor任务执行中提交了子任务，同时当前线程池没有多余的线程可供使用，而母线程等待子线程的结果，子线程等待母线程的计算资源时，也会出现死锁问题。此外，当线程A占有对象锁L时，想要获得另一个对象锁M，线程B持有对象锁M，想要获得对象锁L，两个线程将永远等待下去，这种彼此等待的死锁称为“依赖死锁”。

当一个线程永远占有另一个线程所等待的锁，而另一个线程尝试去获得这个锁，那么它们将永远被阻塞。

• 锁顺序死锁
  哲学家就餐问题中，每位哲学家在尝试获取叉子时，如果顺序不一致（不是按照一个方向，而是每位哲学家任意挑选左右两边的一只筷子），那么就可能导致锁顺序死锁问题,如下图所示。
  

验证锁顺序的一致性需要对程序中锁的行为进行分析，单独观察每一个锁的代码路径并不能得出锁顺序死锁的结论。

public class Test {            public static void main(String[] args) {                Left left = new Left();                Right right = new Right();                left.setRight(right);                right.setLeft(left);                left.start();                right.start();            }            public static class Left extends Thread{                private Right right;                public void setRight(Right right) {                    this.right = right;                }                public void synchronizedLeft() {                    synchronized(this) {                        try {                            Thread.sleep(10);                            //如果把try...catch放到synchronized里面呢？                            synchronized(right) {                                right.sayMyName();                              }                        } catch(Exception e) {                                //操作                        }                    }                }                public void sayMyName() {                    System.out.println("my name is Left");                }                @Override                public void run() {                    this.synchronizedLeft();                }            }            public static class Right extends Thread{                private Left left;                public void setLeft(Left left) {                    this.left = left;                }                public void synchronizedRight() {                    synchronized(this) {                        try {                            Thread.sleep(10);                            //如果把try...catch放到synchronized里面呢？                            synchronized(left) {                                left.sayMyName();                               }                        } catch(Exception e) {                                //操作                        }                    }                }                public void sayMyName() {                    System.out.println("my name is Riht");                }                @Override                public void run() {                    this.synchronizedRight();                }            }           }

从上面的图片和代码中可以看出，锁顺序死锁造成原因是，线程A先锁定Left，在尝试获取Right锁时，Right锁已经被B线程锁定了，而B线程又在等待A线程释放Left锁。所以，如果线程A先锁定了Left，又在B之前锁定了Right，那么锁顺序死锁就不会发生。问题关键，是如何保证获取锁时，另一个线程不会占用资源。
银行进行转账时，两个账户间会不会有死锁问题存在？这也是死锁比较经典的场景。这种常见也比较明显，就是在同一个方法中获取两个锁。

• 协作对象间的死锁

锁顺序死锁在代码分析上比较容易察觉，因为锁的获取口径比较直观，即synchronized嵌套了另一个synchronized。协作对象间的死锁，则不易察觉，因为对象间的方法调用带来了synchronized的嵌套。锁顺序是一种显示的锁定，而协作对象间的锁是隐士的锁顺序。public class Test {    public static void main(String[] args) {        final Left left = new Left();        final Right right = new Right();        left.setRight(right);        right.setLeft(left);        left.start();        right.start();    }    public static class Left extends Thread{        private Right right;        public void setRight(final Right right) {            this.right = right;        }        /**         * 从方法调用上，很难一眼看出synchronized嵌套         */        public synchronized void sayMyName1() {            try {                Thread.sleep(10);                /*                 * 这里是对象间协作时发生了死锁，因为Left获取了锁后，在right中有尝试获取锁，                 * 也就是隐士synchronized嵌套，这种称为对象协作间死锁                 */                this.right.sayMyName1();            } catch(Exception e) {                //操作            }        }        public synchronized void sayMyName2() {            System.out.println("you name is Right");        }        public void run() {            this.sayMyName1();        }    }    public static class Right extends Thread{        private Left left;        public void setLeft(final Left left) {            this.left = left;        }        public synchronized void sayMyName1() {            System.out.println("you name is Left");        }        /**         * 从方法调用上，很难一眼看出synchronized嵌套         */        public synchronized void sayMyName2() {            try {                Thread.sleep(10);                /*                 * 这里是对象间协作时发生了死锁，因为Right获取了锁后，在left中有尝试获取锁，                 * 也就是隐士synchronized嵌套，这种称为对象协作间死锁                 */                this.left.sayMyName2();            } catch(Exception e) {                //操作            }        }        public void run() {            this.sayMyName2();        }    }}

在持有锁的时候调用外部方法要小心死锁问题，因为外部方法可能会获取其他的锁，或者发生阻塞，当一个线程持有锁的时候会阻塞其他尝试获取该锁的线程。