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方法/块内调用的，所以无法获取锁，