死锁案例

JAVA死锁与解决

死锁如何解决

 

互请不循

死锁产生的原因及四个必要条件

产生死锁的原因主要是：

（1） 因为系统资源不足。

（2） 进程运行推进的顺序不合适。

（3） 资源分配不当等。

如果系统资源充足，进程的资源请求都能够得到满足，死锁出现的可能性就很低，否则

就会因争夺有限的资源而陷入死锁。其次，进程运行推进顺序与速度不同，也可能产生死锁。

 

产生死锁的四个必要条件：

（1） 互斥条件：一个资源每次只能被一个进程使用。

（2） 请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放。

（3） 不剥夺条件 : 进程已获得的资源，在末使用完之前，不能强行剥夺。

（4） 循环等待条件 : 若干进程之间形成一种头尾相接的循环等待资源关系。

这四个条件是死锁的必要条件，只要系统发生死锁，这些条件必然成立，而只要上述条件之

一不满足，就不会发生死锁。

 

死锁的解除与预防：

理解了死锁的原因，尤其是产生死锁的四个必要条件，就可以最大可能地避免、预防和

解除死锁。所以，在系统设计、进程调度等方面注意如何不让这四个必要条件成立，如何确

定资源的合理分配算法，避免进程永久占据系统资源。此外，也要防止进程在处于等待状态

的情况下占用资源。因此，对资源的分配要给予合理的规划。

====================================================================

 假设有两个线程，分别代表两个饥饿的人，他们必须共享刀叉并轮流吃饭。他们都需要获得两个锁：共享刀和共享叉的锁。

　　假如线程 “A”获得了刀，而线程“B”获得了叉。线程“A”就会进入阻塞状态来等待获得叉，而线程“B”则阻塞来等待“A”所拥有的刀。这样就造成了死锁。

 

 

避免死锁的一个通用的经验法则是:

当几个线程都要访问共享资源A、B、C时，保证使每个线程都按照同样的顺序去访问它们，比如都先访问A，在访问B和C。 

即让所有的线程按照同样的顺序获得一组锁。

 

 

死锁就是两个或两个以上的线程被无限的阻塞，线程之间相互等待所需资源。这种情况可能发生在当两个线程尝试获取其它资源的锁，而每个线程又陷入无限等待其它资源锁的释放，除非一个用户进程被终止。就 JavaAPI 而言，线程死锁可能发生在一下情况。

• 当两个线程相互调用 Thread.join ()
• 当两个线程使用嵌套的同步块，一个线程占用了另外一个线程必需的锁，互相等待时被阻塞就有可能出现死锁。

 

 

下面这道题，是考死锁的，比较简单，想两个问题：

1.什么时候会造成死锁

2.wait和notify释放了哪个锁，因为题目中有两个锁。

 

import java.util.LinkedList;


public class DeadLockTest {
    LinkedList list = new LinkedList();  
      
    public synchronized void push(Object x) {  
        System.out.println("push");
        synchronized (list) {  
            list.addLast(x);  
            notify();  
        }  
    }  
  
    public synchronized Object pop() throws Exception {    
        synchronized (list) {  
            if (list.size() <= 0) {  
                wait();  
            }  
            return list.removeLast();  
        }  
    }  
    
    public static void main(String[] args) throws InterruptedException {
        final DeadLockTest deadLockTest = new DeadLockTest();
        Thread thread = new Thread(new Runnable() {
            public void run() {
                try {
                    deadLockTest.pop();
                } catch (Exception e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        });
        thread.start();
        Thread.sleep(2000);
        Thread threadPush = new Thread(new Runnable() {
            public void run() {
                try {
                    deadLockTest.push("push thread");
                } catch (Exception e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        });
        threadPush.start();
        
    }
}

 

 

当List为空时，pop的锁一直wait,需要唤醒，而push也获取不到List的锁，进而无法执行notify唤醒方法，所以死锁。

 

来源：http://tomyz0223.iteye.com/blog/1050230

 

Example2:

 

class DeadLockSample{  
    public final Object lock1 = new Object();  
    public final Object lock2 = new Object();    
    public void methodOne(){  
       synchronized(lock1){  
          ...  
          synchronized(lock2){...}  
       }  
    }  
  
    public void methodTwo(){  
       synchronized(lock2){  
      ...  
          synchronized(lock1){...}  
       }  
    }  
}  

 假设场景：线程A调用methodOne()，获得lock1的隐式锁后，在获得lock2的隐式锁之前线程B进入运行，调用methodTwo()，抢先获得了lock2的隐式锁，此时线程A等着线程B交出lock2，线程B等着lock1进入方法块，死锁就这样被创造出来了。 

 

 Example3:

 

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class LockOrdering {
    private Lock lock1 = new ReentrantLock();
    private Lock lock2 = new ReentrantLock();
  
    public void op1() {
        while(true) {
            if(lock1.tryLock()) {//先获取lock1
                try {
                    System.out.println("do sth in op1 with lock1...");
                    try {
                        TimeUnit.SECONDS.sleep(1);
                    } catch (Exception e) {}
                    System.out.println("after sleep in op1");
                     
                    if(lock2.tryLock()) {//再获取lock2
                        try {
                            System.out.println("do sth in op1 with lock2...");
                            return;//退出循环
                        } finally {
                            lock2.unlock();
                        }
                    }
                } finally {
                    lock1.unlock();
                }
            }
        }
    }
  
    public void op2() {
        //锁获取的顺序与op1相反
        while(true) {
            if(lock2.tryLock()) {//先获取lock2
                try {
                    System.out.println("do sth in op2 with lock2...");
                    try {
                        TimeUnit.SECONDS.sleep(1);
                    } catch (Exception e) {}
                    System.out.println("after sleep in op2");
                     
                    if(lock1.tryLock()) {//再获取lock1
                        try {
                            System.out.println("do sth in op2 with lock1...");
                            return;//退出循环
                        } finally {
                            lock1.unlock();
                        }
                    }
                } finally {
                    lock2.unlock();
                }
            }
        }
    }
  
    public static void main(String... args) {
        final LockOrdering test = new LockOrdering();
        new Thread() {
            public void run() {
                test.op1();
            }
        }.start();
        new Thread() {
            public void run() {
                test.op2();
            }
        }.start();
    }
}

 这只是个例子，简单的使用了tryLock，而实际上，带超时时间的重载版本的tryLock更实用。如果上述两个操作都同时做，op1获取lock1，op2获取lock2，op1将获取不到lock2，op2也获取不到lock1，然后op1释放lock1，op2释放lock2，接着又重复这样的操作，就可能导致死循环，当然，这只是理论上的一种可能性，实际CPU要做很多事情，并不会出现这类低概率事件。如果使用带超时时间的tryLock，且每次使用的时间都不同，则几乎可避免这类情况。这有点儿类似网络中的碰撞以及解决碰撞的二进制指数退避算法。

例子3来源：内置锁与LOCK