你的位置:首页 > 操作系统

[操作系统]Android 死锁和重入锁


死锁的定义:

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()方法。
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
【重入锁】
package com.text;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){      System.out.println("synchronized wait()!");       unlock();      wait();     }     isLocked = true;     System.out.println("synchronized lock!");   }    public synchronized void unlock(){     isLocked = false;     notify();     System.out.println("synchronized unlock!");   }      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.lock(); //         l.unlock(); //注释了          System.out.println("Lock!");         } catch (InterruptedException e) {           e.printStackTrace();         }       else          l.unlock();     }        } } 

输出:

synchronized lock!
Lock!
synchronized wait()!
synchronized unlock!

在一个synchronized方法/块的内部调用本类的其他synchronized方法/块时,是永远可以获得锁的。

 

 

 

 

package com.text;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){      System.out.println("synchronized wait()!");       wait();     }     isLocked = true;     System.out.println("synchronized lock!");   }    public synchronized void unlock(){     isLocked = false;     notify();     System.out.println("synchronized unlock!");   }      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.lock();           l.unlock(); //取消注释了          System.out.println("Lock!");         } catch (InterruptedException e) {           e.printStackTrace();         }       else          l.unlock();     }        } } 

输出:

synchronized lock!
Lock!
synchronized wait()!

因为连续两个lock方法,导致在第二次时形成死锁,第三次的unlock由于不是在synchronized方法/块内调用的,所以无法获取锁,