死锁

现代的计算机伴随着多核 CPU 的出现,不同的线程能在不同的 CPU 核并行执行。而多线程是在同一个程序内部并行执行,因此会对相同的内存空间进行并发读写操作。

这可能出现某些无法预测的问题。就像,如果两个线程同时写入同一个内存,那在操作完成后将会是什么结果?是第一个线程写入的值?还是第二个线程写入的值?或是两者兼具?

如果一个线程在读一个内存时,另一个线程正向该内存进行写操作,那又会怎样呢?是写操作之前旧的值?还是写操作成功之后的新值?

因此如没有合适的预防措施,任何结果都是可能的。而且这种行为的发生甚至不能预测,所以结果也是不确定性的。


死锁

死锁是两个或更多线程阻塞着等待其它处于死锁状态的线程所持有的锁。死锁通常发生在多个线程同时但以不同的顺序请求同一组锁的时候。

线程 A 占有资源 R,请求资源 S。线程 B 占有资源 S,请求资源 R。线程 A 和 B 都会因为请求不到自己的资源而阻塞。这就是死锁。

死锁视图.jpg

可以形象的看作:

小猫追尾巴,转圈圈。

死锁产生的条件

  • 互斥条件:每个资源要么已经分配给一个进程,要么是可用的。

  • 占有和等待条件:已经占有资源的进程可以申请其他资源。

  • 不可抢占条件:已经被占有的资源不能被其他的进程抢占, 只有占有它的进程才能显示释放。

  • 环路等待条件:死锁发生时,系统中有两个或两个以上的进程一条环路,该环路中的每一个进程都在等待下一个进程所占有的资源。

死锁发生时,以上的四个条件必须同时满足,如果有其中的一个条件不满足,死锁就不会发生。


这里有一个 LockTest 类的例子,它调用了不同实例的 synchronized 方法:

public class LockTest {
   public static String obj1 = "R";
   public static String obj2 = "S";
   public static void main(String[] args) {
      LockA la = new LockA();
      new Thread(la).start();
      LockB lb = new LockB();
      new Thread(lb).start();
   }
}
class LockA implements Runnable{
   public void run() {
      try {
         System.out.println(new Date().toString() + " LockA 开始执行");
         while(true){
            synchronized (LockTest.obj1) {
               System.out.println(new Date().toString() + " LockA 锁住 R");
               Thread.sleep(3000); // 此处等待是给B能锁住机会
               synchronized (LockTest.obj2) {
                  System.out.println(new Date().toString() + " LockA 锁住 S");
                  Thread.sleep(60 * 1000); // 为测试,占用了就不放
               }
            }
         }
      } catch (Exception e) {
         e.printStackTrace();
      }
   }
}
class LockB implements Runnable{
   public void run() {
      try {
         System.out.println(new Date().toString() + " LockB 开始执行");
         while(true){
            synchronized (LockTest.obj2) {
               System.out.println(new Date().toString() + " LockB 锁住S");
               Thread.sleep(3000); // 此处等待是给A能锁住机会
               synchronized (LockTest.obj1) {
                  System.out.println(new Date().toString() + " LockB R");
                  Thread.sleep(60 * 1000); // 为测试,占用了就不放
               }
            }
         }
      } catch (Exception e) {
         e.printStackTrace();
      }
   }
}

输出结果:

Thu Apr 06 23:14:10 GMT+08:00 2017 LockB 开始执行
Thu Apr 06 23:14:10 GMT+08:00 2017 LockB 锁住S
Thu Apr 06 23:14:10 GMT+08:00 2017 LockA 开始执行
Thu Apr 06 23:14:10 GMT+08:00 2017 LockA 锁住 R

如果线程 A 调用 Runnable() 方法的同时有另外一个线程 B 调用 Runnable() 方法,两个线程相互锁住资源不放,此时就会发生死锁。下面的伪代码说明了这个过程:

Thread A:synchronized (LockTest.obj1); //locks R
--> synchronized (LockTest.obj1);

Thread B: synchronized (LockTest.obj1); //locks S
--> synchronized (LockTest.obj1)

首先线程 A 调用 start()方法。因为 LockTest.obj1 是同步的,所以线程 A 会对 obj1 对象(资源 R)加锁以不让其它线程访问该对象。

然后线程 B 调用 start()方法。因为 LockTest.obj2 也是同步的,所以线程 B 会对 obj2 对象(资源 S)加锁以不让其它线程访问该对象。

现在 obj1 和 obj2 对象被两个不同的线程锁住了。接下来线程 A 尝试请求资源 S,但是由于 obj2 对象现在被线程 B 锁住的,所以该调用会被阻塞。线程 B 也尝试请求资源 R,但是由于 obj1 对象现在被线程 A 锁住,导致线程 B 也阻塞在该方法处。现在两个线程都被阻塞并等待着获取另外一个线程所持有的锁。

正常而言,上面的代码可能运行一段时间才会出现死锁。故而,在代码中让线程等待以给另一个线程锁住资源的机会。

这些线程需要同时获得锁。举个例子,如果线程 A 稍微领先线程 B,然后成功地锁住了 R 和 S 两个对象,那么线程 B 就会在尝试对 S 加锁的时候被阻塞,这样死锁就不会发生。因为线程调度通常是不可预测的,因此没有一个办法可以准确预测什么时候死锁会发生,仅仅是可能会发生。

最后编辑于
©著作权归作者所有,转载或内容合作请联系作者
平台声明:文章内容(如有图片或视频亦包括在内)由作者上传并发布,文章内容仅代表作者本人观点,简书系信息发布平台,仅提供信息存储服务。

推荐阅读更多精彩内容

  • 1、竞态条件: 定义:竞态条件指的是一种特殊的情况,在这种情况下各个执行单元以一种没有逻辑的顺序执行动作,从而导致...
    Hughman阅读 1,326评论 0 7
  • 概述 线程本身由于创建和切换的开销,采用多线程不会提高程序的执行速度,反而会降低速度,但是对于频繁IO操作的程序,...
    wustor阅读 675评论 0 1
  • 死锁产生的原因和解锁的方法 产生死锁的四个必要条件: (1) 互斥条件:一个资源每次只能被一个进程使用。 (2) ...
    憩在河岸上的鱼丶阅读 1,493评论 0 4
  • 思路:创建两个字符串a和b,再创建两个线程A和B,让每个线程都用synchronized锁住字符串(A先锁a,再去...
    zxk175阅读 324评论 0 0
  • 20.1死锁概念 由于竞争资源或者通信关系,两个或更多线程在执行中出现,永远相互等待只能由其他进程引发的事件 进程...
    龟龟51阅读 656评论 0 1