为了防止对共享受限资源的争夺,我们可以通过synchronized等方式来加锁,这个时候该线程就处于阻塞状态,设想这样一种情况,线程A等着线程B完成后才能执行,而线程B又等着线程C,而线程C又等着线程A。这三个任务之间相互循环等待,但是其实没有哪个任务能够执行,这种情况就发生了死锁。
有一个经典的哲学家就餐问题,可以更清晰的理解死锁问题。有N个哲学家围绕在一张圆形餐桌前,餐桌中间有一份面条,每个哲学家都只有一根筷子,放在他的左手边。(因为餐桌是圆形的,所以就是每两个哲学家之间有一根筷子),所以共计有N个哲学家,N个筷子, 哲学们家们有时候思考,思考时不需要获取其他共享资源;有时候吃面条,吃面条时需要两根筷子,哲学家需要先拿到他right手边的筷子,然后再去拿left手边的筷子。如果此时,left手边筷子不在桌子上(被边上的哲学家拿走了)。则哲学家就把right手边的筷子拿在手中等待。 (调用wait).等待left边的筷子被放下。如果哲学家吃完面条,则放下两根筷子 ,继续思考。
我们仅仅通过逻辑思考,就可以想到如果每个哲学家都拿到了他right手边的筷子,那么此时就发生了死锁,因为实际上桌子上,每个哲学家正好拿到了一根筷子,都在等待他left手边的筷子被放下,但是不会再有筷子被放下了.
代码demo:src\thread_runnable\DeadLockingDiningPhiosophers.java
1 class Chopstick{ 2 private boolean taken = false; 3 //拿起筷子 4 public synchronized void take() throws InterruptedException{ 5 while (taken){ 6 wait(); 7 } 8 TimeUnit.MILLISECONDS.sleep(100); 9 taken = true; 10 } 11 //放下筷子 12 public synchronized void drop(){ 13 taken = false; 14 notify(); 15 } 16 } //end of "class Chopstick" 17 18 class Philosopher implements Runnable{ 19 private Chopstick left; 20 private Chopstick right; 21 private final int id; 22 private int eatTime; 23 private int thinkTime; 24 private Random rand = new Random(42); //the Answer to Life, the Universe and Everything is 42 25 26 public Philosopher(Chopstick left, Chopstick right, int id, int eatTime, int thinkTime) { 27 super(); 28 this.left = left; 29 this.right = right; 30 this.id = id; 31 this.eatTime = eatTime; 32 this.thinkTime = thinkTime; 33 } 34 35 //思考/或者吃饭的一段时间。 36 private void pause(int time) throws InterruptedException{ 37 TimeUnit.MILLISECONDS.sleep(rand.nextInt(time*20)); 38 } 39 40 @Override 41 public void run() { 42 // TODO Auto-generated method stub 43 try { 44 while (!Thread.interrupted()){ 45 System.out.println(this + "thinking"); 46 pause(thinkTime); 47 //哲学家开始吃饭了 48 System.out.println(this + "grabbing right"); 49 right.take(); 50 System.out.println(this + "grabbing left"); 51 left.take(); 52 System.out.println(this + "grabbing eating"); 53 pause(eatTime); 54 //吃完了。可以放下筷子了 55 right.drop(); 56 left.drop(); 57 58 } 59 } catch (InterruptedException e) { 60 // TODO: handle exception 61 System.out.println(this + " exiting via interrupt"); 62 } 63 } 64 65 @Override 66 public String toString() { 67 return "Philosopher id=" + id + "\t"; 68 } 69 70 71 72 }//end of "class Philosopher" 73 74 public class DeadLockingDiningPhiosophers { 75 //哲学家和筷子的数量 76 private static final int N = 3; 77 private static final int eatTime = 20; 78 private static final int thinkTime = 3; 79 80 public static void main(String[] args) throws Exception{ 81 ExecutorService exec = Executors.newCachedThreadPool(); 82 int ponder = 1; 83 Chopstick[] sticks = new Chopstick[N]; 84 85 for (int i=0; i<N; i++){ 86 sticks[i] = new Chopstick(); 87 } 88 89 for (int i=0; i<N; i++){ 90 exec.execute(new Philosopher(sticks[i], sticks[(i+1)%N], i, eatTime, thinkTime)); 91 } 92 93 } 94 95 }
代码分析: 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