Chinaunix首页 | 论坛 | 博客
  • 博客访问: 1159151
  • 博文数量: 237
  • 博客积分: 5139
  • 博客等级: 大校
  • 技术积分: 2751
  • 用 户 组: 普通用户
  • 注册时间: 2008-11-18 14:48
文章分类

全部博文(237)

文章存档

2016年(1)

2012年(4)

2011年(120)

2010年(36)

2009年(64)

2008年(12)

分类: Java

2011-03-26 11:51:09

死锁

  死锁是这样一种情形:多个线程同时被阻塞,它们中的一个或者全部都在等待某个资源被释放。由于线程被无限期地阻塞,因此程序不可能正常终止。

  导致死锁的根源在于不适当地运用“synchronized”关键词来管理线程对特定对象的访问。“synchronized”关键词的作用是,确保在某个时刻只有一个线程被允许执行特定的代码块,因此,被允许执行的线程首先必须拥有对变量或对象的排他性的访问权。当线程访问对象时,线程会给对象加锁,而这个锁导致其它也想访问同一对象的线程被阻塞,直至第一个线程释放它加在对象上的锁。

  由于这个原因,在使用“synchronized”关键词时,很容易出现两个线程互相等待对方做出某个动作的情形。代码一是一个导致死锁的简单例子。

//代码一
Java代码  
  1. class Deadlocker {   
  2.  int field_1;   
  3.  private Object lock_1 = new int[1];   
  4.  int field_2;   
  5.  private Object lock_2 = new int[1];   
  6.   
  7.  public void method1(int value) {   
  8.   “synchronized” (lock_1) {   
  9.    “synchronized” (lock_2) {   
  10.     field_1 = 0; field_2 = 0;   
  11.    }   
  12.   }   
  13.  }   
  14.   
  15.  public void method2(int value) {   
  16.   “synchronized” (lock_2) {   
  17.    “synchronized” (lock_1) {   
  18.     field_1 = 0; field_2 = 0;   
  19.    }   
  20.   }   
  21.  }   
  22. }   
  23.    
class Deadlocker { int field_1; private Object lock_1 = new int[1]; int field_2; private Object lock_2 = new int[1]; public void method1(int value) { “synchronized” (lock_1) { “synchronized” (lock_2) { field_1 = 0; field_2 = 0; } } } public void method2(int value) { “synchronized” (lock_2) { “synchronized” (lock_1) { field_1 = 0; field_2 = 0; } } } }

  参考代码一,考虑下面的过程:

  ◆ 一个线程(ThreadA)调用method1()。

  ◆ ThreadA在lock_1上同步,但允许被抢先执行。

  ◆ 另一个线程(ThreadB)开始执行。

  ◆ ThreadB调用method2()。

  ◆ ThreadB获得lock_2,继续执行,企图获得lock_1。但ThreadB不能获得lock_1,因为ThreadA占有lock_1。

  ◆ 现在,ThreadB阻塞,因为它在等待ThreadA释放lock_1。

  ◆ 现在轮到ThreadA继续执行。ThreadA试图获得lock_2,但不能成功,因为lock_2已经被ThreadB占有了。

  ◆ ThreadA和ThreadB都被阻塞,程序死锁。

  当然,大多数的死锁不会这么显而易见,需要仔细分析代码才能看出,对于规模较大的多线程程序来说尤其如此。好的线程分析工具,例如JProbe Threadalyzer能够分析死锁并指出产生问题的代码位置。

  隐性死锁

  隐性死锁由于不规范的编程方式引起,但不一定每次测试运行时都会出现程序死锁的情形。由于这个原因,一些隐性死锁可能要到应用正式发布之后才会被发现,因此它的危害性比普通死锁更大。下面介绍两种导致隐性死锁的情况:加锁次序和占有并等待。

  加锁次序

  当多个并发的线程分别试图同时占有两个锁时,会出现加锁次序冲突的情形。如果一个线程占有了另一个线程必需的锁,就有可能出现死锁。考虑下面的情形,ThreadA和ThreadB两个线程分别需要同时拥有lock_1、lock_2两个锁,加锁过程可能如下:

  ◆ ThreadA获得lock_1;

  ◆ ThreadA被抢占,VM调度程序转到ThreadB;

  ◆ ThreadB获得lock_2;

  ◆ ThreadB被抢占,VM调度程序转到ThreadA;

  ◆ ThreadA试图获得lock_2,但lock_2被ThreadB占有,所以ThreadA阻塞;

  ◆ 调度程序转到ThreadB;

  ◆ ThreadB试图获得lock_1,但lock_1被ThreadA占有,所以ThreadB阻塞;

  ◆ ThreadA和ThreadB死锁。

  必须指出的是,在代码丝毫不做变动的情况下,有些时候上述死锁过程不会出现,VM调度程序可能让其中一个线程同时获得lock_1和lock_2两个锁,即线程获取两个锁的过程没有被中断。在这种情形下,常规的死锁检测很难确定错误所在。

  占有并等待

  如果一个线程获得了一个锁之后还要等待来自另一个线程的通知,可能出现另一种隐性死锁,考虑代码二。

//代码二
Java代码  
  1. public class queue {   
  2.  static java.lang.Object queueLock_;   
  3.  Producer producer_;   
  4.  Consumer consumer_;   
  5.   
  6.  public class Producer {   
  7.   void produce() {   
  8.    while (!done) {   
  9.     “synchronized” (queueLock_) {   
  10.      produceItemAndAddItToQueue();   
  11.      “synchronized” (consumer_) {   
  12.       consumer_.notify();   
  13.      }   
  14.     }   
  15.    }   
  16.   }   
  17.   
  18.   public class Consumer {   
  19.    consume() {   
  20.     while (!done) {   
  21.      “synchronized” (queueLock_) {   
  22.       “synchronized” (consumer_) {   
  23.        consumer_.wait();   
  24.       }   
  25.       removeItemFromQueueAndProcessIt();   
  26.      }   
  27.     }   
  28.    }   
  29.   }   
  30.  }   
  31. }   
  32.    
public class queue { static java.lang.Object queueLock_; Producer producer_; Consumer consumer_; public class Producer { void produce() { while (!done) { “synchronized” (queueLock_) { produceItemAndAddItToQueue(); “synchronized” (consumer_) { consumer_.notify(); } } } } public class Consumer { consume() { while (!done) { “synchronized” (queueLock_) { “synchronized” (consumer_) { consumer_.wait(); } removeItemFromQueueAndProcessIt(); } } } } } }


  在代码二中,Producer向队列加入一项新的内容后通知Consumer,以便它处理新的内容。问题在于,Consumer可能保持加在队列上的锁,阻止Producer访问队列,甚至在Consumer等待Producer的通知时也会继续保持锁。这样,由于Producer不能向队列添加新的内容,而Consumer却在等待Producer加入新内容的通知,结果就导致了死锁。

  在等待时占有的锁是一种隐性的死锁,这是因为事情可能按照比较理想的情况发展—Producer线程不需要被Consumer占据的锁。尽管如此,除非有绝对可靠的理由肯定Producer线程永远不需要该锁,否则这种编程方式仍是不安全的。有时“占有并等待”还可能引发一连串的线程等待,例如,线程A占有线程B需要的锁并等待,而线程B又占有线程C需要的锁并等待等。

  要改正代码二的错误,只需修改Consumer类,把wait()移出“synchronized”()即可。

  因此避免死锁的一个通用的经验法则是:当几个线程都要访问共享资源A、B、C时,保证使每个线程都按照同样的顺序去访问它们,比如都先访问A,在访问B和C。
  此外,Thread类的suspend()方法也很容易导致死锁,因此这个方法已经被废弃了.

阅读(2576) | 评论(0) | 转发(0) |
0

上一篇:产生死锁的原因

下一篇:Java基础

给主人留下些什么吧!~~