java多线程(八)－死锁问题和java多线程总结

为了防止对共享受限资源的争夺，我们可以通过synchronized等方式来加锁，这个时候该线程就处于阻塞状态，设想这样一种情况，线程A等着线程B完成后才能执行，而线程B又等着线程C，而线程C又等着线程A。这三个任务之间相互循环等待，但是其实没有哪个任务能够执行，这种情况就发生了死锁。

有一个经典的哲学家就餐问题，可以更清晰的理解死锁问题。有N个哲学家围绕在一张圆形餐桌前，餐桌中间有一份面条，每个哲学家都只有一根筷子，放在他的左手边。（因为餐桌是圆形的，所以就是每两个哲学家之间有一根筷子），所以共计有N个哲学家，N个筷子， 哲学们家们有时候思考，思考时不需要获取其他共享资源；有时候吃面条，吃面条时需要两根筷子，哲学家需要先拿到他right手边的筷子，然后再去拿left手边的筷子。如果此时，left手边筷子不在桌子上（被边上的哲学家拿走了）。则哲学家就把right手边的筷子拿在手中等待。 (调用wait).等待left边的筷子被放下。如果哲学家吃完面条，则放下两根筷子 ，继续思考。

我们仅仅通过逻辑思考，就可以想到如果每个哲学家都拿到了他right手边的筷子，那么此时就发生了死锁，因为实际上桌子上，每个哲学家正好拿到了一根筷子，都在等待他left手边的筷子被放下，但是不会再有筷子被放下了.

代码demo：src\thread_runnable\DeadLockingDiningPhiosophers.java

 class Chopstick{
     private boolean taken = false;
     //拿起筷子
     public synchronized void take() throws InterruptedException{
         while (taken){
             wait();
         }
         TimeUnit.MILLISECONDS.sleep(100);
         taken = true;
     }
     //放下筷子
     public synchronized void drop(){
         taken = false;
         notify();
     }
 } //end of "class Chopstick"

 class Philosopher implements Runnable{
     private Chopstick left;
     private Chopstick right;
     private final int id;
     private int eatTime;
     private int thinkTime;
     private Random rand = new Random(42); //the Answer to Life, the Universe and Everything is 42

     public Philosopher(Chopstick left, Chopstick right, int id, int eatTime, int thinkTime) {
         super();
         this.left = left;
         this.right = right;
         this.id = id;
         this.eatTime = eatTime;
         this.thinkTime = thinkTime;
     }

     //思考/或者吃饭的一段时间。
     private void pause(int time) throws InterruptedException{
         TimeUnit.MILLISECONDS.sleep(rand.nextInt(time*20));
     }

     @Override
     public void run() {
         // TODO Auto-generated method stub
         try {
             while (!Thread.interrupted()){
                 System.out.println(this + "thinking");
                 pause(thinkTime);
                 //哲学家开始吃饭了
                 System.out.println(this + "grabbing right");
                 right.take();
                 System.out.println(this + "grabbing left");
                 left.take();
                 System.out.println(this + "grabbing eating");
                 pause(eatTime);
                 //吃完了。可以放下筷子了
                 right.drop();
                 left.drop();

             }
         } catch (InterruptedException e) {
             // TODO: handle exception
             System.out.println(this + "  exiting via interrupt");
         }
     }

     @Override
     public String toString() {
         return "Philosopher id=" + id + "\t";
     }

 }//end of "class Philosopher"

 public class DeadLockingDiningPhiosophers {
     //哲学家和筷子的数量
     private static final int N = 3;
     private static final int eatTime = 20;
     private static final int thinkTime = 3;

     public static void main(String[] args) throws Exception{
         ExecutorService exec = Executors.newCachedThreadPool();
         int ponder = 1;
         Chopstick[] sticks = new Chopstick[N];

         for (int i=0; i<N; i++){
             sticks[i] = new Chopstick();
         }

         for (int i=0; i<N; i++){
             exec.execute(new Philosopher(sticks[i], sticks[(i+1)%N], i, eatTime, thinkTime));
         }

     }

 }

代码分析: Chopstick对象有 take(拿起)和 drop(放下)两个动作，而哲学家对象呢，不管是吃饭过程，还是思考过程，都是模拟sleep随机的时间， 吃完饭之后，放下筷子，进行思考。不间断进行循环。

在demo中，3个线程，分别执行3个哲学家的任务， 同时也只有3个筷子。
按照我们的测试，有概率会发生死锁。为了增大死锁发生的概率，便于测试，我们将拿起筷子的时间延长了。（就是在take方法中sleep(100)）.

进行测试，很快就发生了死锁。
其中一次的输出结果：

从控制台可以看出，程序一直在运行，但是哲学家们却不会再吃饭和思考了。
从输出信息看出，
1,0,2号哲学家依次拿起了right边的筷子 ，然后再准备拿起left边的筷子时，因为没有筷子了，而陷入了漫长的wait()中，这个时候，死锁发生了。程序死掉了。

对于哲学家就餐问题，我们可以想出一个避免死锁的方案，比如，对于其中的某一位哲学家，限定其先拿left边的筷子，再拿right边的筷子。（和其余的哲学家正好相反）。

死锁问题最难的地方是在于它是小概率性的，并且可能隐藏相当长的时间才会发生，并且每次发生死锁时，都是不可重现的。这在实际的项目中，会引起非常难以调试的bug。
而在实际项目中，必现的bug都容易解决，小概率的，不可重现的bug那才真的让人头疼。

程序避免死锁并不是件容易的事情，但是遵循以下原则则可以尽量避免死锁。
(1),使用锁的时间尽可能的短，考虑使用同步语句块来代替同步方法。
(2),尽量避免代码在同一个时刻需要多个锁。
(3),创建和使用一个大锁来代替若干把小锁，并且用这把锁用于互斥。

总结：
多线程问题算是java当中比较高级的内容了，当然因为能力有限，我的这几篇博客写的也非常肤浅。而实际编码中，是否应该使用多线程，也应该仔细斟酌。
使用多线程应该基于以下几个原因。
(1),处理交织在一起的很多任务。
(2),更高效的应用计算机资源。（比如多核cpu，等待I/O）,
(3),更好的组织代码。
(4)更好的用户体验。(比如UI界面)

但是多线程也有一些缺点要注意。
(1),等待共享资源时，降低效率。
(2),上下文切换需要耗费额外的资源。
(3),多线程也会增加代码复杂度。
(4),可能会导致一些难以调试的bug。比如死锁。
(5),平台差异性。

如果线程问题过于复杂，java的多线程机制不能满足要求，那么应该使用类似Erlang这样的 专门面向并发的的函数性语言。

这几篇java多线程文章的demo代码下载地址 http://download.csdn.net/detail/yaowen369/9786452

---

作者: www.yaoxiaowen.com
github: https://github.com/yaowen369