死锁的三种形式:一般死锁,嵌套管程锁死,重入锁死

转载 2016年05月31日 22:23:02

死锁的定义:

死锁一般是指两个(或两个以上)线程同时竞争两个(或者多个)资源,从而产生同时等待的现象,使得系统僵持不动。

顺便复习一下线程与进程的定义以及他们之间的区别。

进程:一个有独立功能的程序利用某些数据资源的一次远行过程。

线程:一个进程里面的一条执行路径(或者执行过程),同一条进程下的n多条线程之间可以互相通信(共享数据)。

区别:进程是相对独立的单位, 进程和线程的主要差别在于它们是不同的操作系统资源管理方式。

进程有独立的地址空间,一个进程崩溃后,在保护模式下不会对其它进程产生影响,而线程

只是一个进程中的不同执行路径。 线程有自己的堆栈和局部变量,但线程之间没有单独的地址空间,

一个线程死掉就等于整个进程死掉,所以多进程的程序要比多线程的程序健壮,但在进程切换时,

耗费资源较大,效率要差一些。但对于一些要求同时进行并且又要共享某些变量的并发操作,

只能用线程,不能用进程。

总之:进程是相对独立的,一个进程的崩溃不会影响到其他进程,但是一个线程必须依赖于进程的存在而存在,

线程之间可以共享数据。

一般死锁产生的示例图:

1、一般的死锁

一般的死锁是指多个线程的执行必须同时拥有多个资源,由于不同的线程需要的资源被不同的线程占用,最终导致僵持的状态,这就是一般死锁的定义。

package com.cxt.thread;

public class TestDeadLock extends Thread{
  boolean b;
  DeadLock lock;
  public TestDeadLock(boolean b, DeadLock lock) {
    super();
    this.b = b;
    this.lock = lock;
  }
  public static void main(String[] args) {
    DeadLock lock = new DeadLock();
    TestDeadLock t1 = new TestDeadLock(true, lock);
    TestDeadLock t2 = new TestDeadLock(false, lock);
    t1.start();
    t2.start();
  }
  @Override
  public void run() {
    if(this.b){
      lock.m1();
    }
    else
      lock.m2();
  }
  
}

class DeadLock {
  Object o1 = new Object();
  Object o2 = new Object();
  
  void m1(){
    synchronized(o1){
      System.out.println("m1 Lock o1 first");
      synchronized(o2){
        System.out.println("m1 Lock o2 second");
      }
    }
  }
  void m2(){
    synchronized(o2){
      System.out.println("m2 Lock o2 first");
      synchronized(o1){
        System.out.println("m2 Lock o1 second");
      }
    }
  }
}
如代码所示我们可知:线程t1,t2都需要对象o1,o2才能正常地完成功能,但是由于他们所持的对象与要获得的对象刚好相反,使得两条线程一直僵持,

最终导致死锁。

解决方法:等其中一条线程完全执行完之后再执行另外一条线程。

推广到多条线程,按一定的顺序执行多条线程。

另外一种方法就是设置优先级,如果运行多条线程出现死锁,优先级低的回退,优先级高的先执行这样即可解决死锁问题。

2、嵌套管程锁死

线程1获得A对象的锁。
线程1获得对象B的锁(同时持有对象A的锁)。
线程1决定等待另一个线程的信号再继续。
线程1调用B.wait(),从而释放了B对象上的锁,但仍然持有对象A的锁。

线程2需要同时持有对象A和对象B的锁,才能向线程1发信号。
线程2无法获得对象A上的锁,因为对象A上的锁当前正被线程1持有。
线程2一直被阻塞,等待线程1释放对象A上的锁。

线程1一直阻塞,等待线程2的信号,因此,不会释放对象A上的锁,
  而线程2需要对象A上的锁才能给线程1发信号……
看代码:
package com.cxt.Lock;

import com.cxt.thread.Synchronizer;
import com.cxt.thread.TestLock;

//lock implementation with nested monitor lockout problem
/**
 * 一个坑爹的嵌套管程锁死,区别于死锁
 */
public class Lock {
  protected MonitorObject monitorObject = new MonitorObject();
  protected boolean isLocked = false;

  public static void main(String[] args) {
    Lock l = new Lock();
    l.isLocked = true;

    MyRunnable r1 = new MyRunnable(l, 0);
    MyRunnable r2 = new MyRunnable(l, 0);
    Thread t1 = new Thread(r1);
    Thread t2 = new Thread(r2);
    t1.start();
    t2.start();
    /*
     * 時而鎖住,時而釋放,因為另外兩條線程沒有有时捕捉不到isLocked = false
     */
//		for (int i = 0; i < 100; i++) {
//			l.isLocked = false;
//			try {
//				Thread.sleep(10);
//			} catch (InterruptedException e) {
//				e.printStackTrace();
//			}
//		}
    //

  }

  public void lock() throws InterruptedException {
    // 当执行这个方法时,isLocked=true时,其他方法无论执行lock方法还是执行Unlock方法都会导致管程死锁
    // 只有手动将isLocked 设置为false才能解决死锁,设置为false时必须让其他线程检测到,所以必须设置时间长一点
    synchronized (this) {
      while (isLocked) {
        synchronized (this.monitorObject) {
          this.monitorObject.wait();
        }
      }
      isLocked = true;
    }
  }

  public void unlock() {
    synchronized (this) {
      this.isLocked = false;
      synchronized (this.monitorObject) {
        this.monitorObject.notify();
      }
    }
  }

  static class MyRunnable implements Runnable {
    Lock l = null;
    int i;

    public MyRunnable(Lock l, int i) {
      this.l = l;
      this.i = i;
    }

    @Override
    public void run() {
      try {
        if (i % 2 == 0) {
          this.l.lock();
        } else {
          this.l.unlock();
        }
      } catch (InterruptedException e) {
        e.printStackTrace();
      }
    }

  }
}
我们观察lock()方法,执行lock()时,当isLocked 为true时,问题就来了,执行monitorObject的方法块,

但是monitorObject变成了等待状态,但是这是外面的this锁还是被此线程持有的,如果有其他线程要执行lock()

或者unLock(),此时都会产生无限等待的状态,此线程也因此永远处于无限带等待其他线程来唤醒monitorObject的状态,

最终就一直僵持着。

解决方法手动将isLocked设为false.

这一种较坑,编代码时别没事找事做。

3、重入锁死

package com.cxt.Lock;

public class Lock2{
  private boolean isLocked = false;
  
  public static void main(String[] args) {
    Lock2 lock = new Lock2();
    
    MyRunnable r1 = new MyRunnable(lock, true);
    MyRunnable r2 = new MyRunnable(lock, false);
    Thread t1 = new Thread(r1);
    Thread t2 = new Thread(r2);
    t1.start();
    
//		t2.start();
  }
  public synchronized void lock()
    throws InterruptedException{
    while(isLocked){
      wait();
    }
    isLocked = true;
  }

  public synchronized void unlock(){
    isLocked = false;
    notify();
  }
  
  static class MyRunnable implements Runnable{
    Lock2 l = null;
    boolean flag = false;
    public MyRunnable(Lock2 l, boolean flag) {
      this.l = l;
      this.flag = flag;
    }
    @Override
    public void run() {
      if(flag == true)
        try {
//					如果连续执行两次lock(),就会产生系统无限等待的状态
//					解决方法就是在两次中间执行一次unLock()方法
          l.lock();
          System.out.println("Lock!");
//					l.unlock();
//					System.out.println("Unlock!");
          l.lock();
          System.out.println("Lock!");
        } catch (InterruptedException e) {
          e.printStackTrace();
        }
      else 
        l.unlock();
    }
    
  }
}
当连续执行两次lock()时会出现:

第一次,isLocked为false,执行完把isLocked设为true.

第二次,isLocked为true,此时就会处于无限等待的状态。

解决方法,两个lock()中间执行一次unLock方法,或者由另外一条线程来执行一次unLock()方法。

重入的概念: 如果一个线程持有某个管程对象上的锁,那么它就有权访问所有在该管程对象上同步的块。这就叫可重入。若线程已经持有锁,那么它就可以重复访问所有使用该锁的代码块。

显然这个例子是不可以重入的!

Mongodb性能调优

摘要 1. Mongodb 适用场景简介 2. Mongodb 性能监控与分析 3. Mongodb 性能优化建议关于Mongodb的几个大事件 1.根据美国数据库知识大全官网发布的DB...
  • hexieshangwang
  • hexieshangwang
  • 2015年09月30日 15:10
  • 409963

Activemq死锁的问题

开发过程中遇到一个activemq死锁的问题,痛苦经历:  应用场景: 后台进程(appserver1)不断产生任务, 发送到queue上 前台应用(appservers)请求过来,到...
  • Adub
  • Adub
  • 2007年03月06日 10:04
  • 1971

不当事务代码引起的数据库死锁问题

错误案例 DBA反映IBANK线上数据库报警,检测到死锁,跟踪到发生死锁等待的两条SQL语句分别为: UPDATE WP_IMAGE_SORT SET GMT_MODIFIED = SYSDATE,I...
  • Rubenyu
  • Rubenyu
  • 2011年07月06日 09:11
  • 4176

多线程——同步嵌套造成死锁问题

package com.qianfeng.demo02; /** * 同步的另外一个弊端:死锁 * * 最常见的死锁的情况: * 同步嵌套,同步中还有同步,然后两个同步用的不是一把锁。 *...
  • u012369385
  • u012369385
  • 2016年08月20日 10:12
  • 1490

5.5.24,一个怪异的死锁问题导致DB无法连接

故障现象: mysql 5.5.24,突然所有新连接卡住,db无法连接,无任何报错 故障原因分析: 找到对应的mysqld进程号,pstack $pid > /tmp/jj.sql Thread ...
  • cug_jiang126com
  • cug_jiang126com
  • 2016年11月10日 12:26
  • 487

死锁的三种形式:一般死锁,嵌套管程锁死,重入锁死

死锁的总结 死锁的定义: 死锁一般是指两个(或两个以上)线程同时竞争两个(或者多个)资源,从而产生同时等待的现象,使得系统僵持不动。 顺便复习一下线程与进程的定义以及他们之间的区别。 进程:一...
  • oChenXiaoZuo1
  • oChenXiaoZuo1
  • 2014年07月28日 21:15
  • 1628

多线程——同步嵌套造成死锁问题

package com.qianfeng.demo02; /** * 同步的另外一个弊端:死锁 * * 最常见的死锁的情况: * 同步嵌套,同步中还有同步,然后两个同步用的不是一把锁。 *...
  • u012369385
  • u012369385
  • 2016年08月20日 10:12
  • 1490

Java通过锁的顺序避免死锁

例子银行账户转账问题,两个用户转账的话,如果采用一般的synchronized嵌套的话,容易造成死锁,现在我们通过类似哲学家问题的解决方案一样:先获取同一个锁,才有资格获取下一个。而判断是通过Syst...
  • renwotao2009
  • renwotao2009
  • 2016年04月07日 11:17
  • 1946

java 嵌套管程锁死

嵌套管程锁死类似于死锁, 下面是一个嵌套管程锁死的场景:线程1获得A对象的锁。 线程1获得对象B的锁(同时持有对象A的锁)。 线程1决定等待另一个线程的信号再继续。 线程1调用B.wait(),从而释...
  • qilixiang012
  • qilixiang012
  • 2015年05月10日 17:10
  • 519

GCD,Operation Queues,Run Loops,如何在后台绘制UI,后台I/O处理,最佳安全实践避免互斥锁死锁优先级反转等,以及如何使用GCD监视进程文件文件夹,并发测试的方案等

iOS并发编程笔记,包含GCD,Operation Queues,Run Loops,如何在后台绘制UI,后台I/O处理,最佳安全实践避免互斥锁死锁优先级反转等,以及如何使用GCD监视进程文件文件夹,...
  • quanqinayng
  • quanqinayng
  • 2015年05月14日 01:03
  • 890
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:死锁的三种形式:一般死锁,嵌套管程锁死,重入锁死
举报原因:
原因补充:

(最多只允许输入30个字)