死锁-java实现死锁的简单例子

死锁

是指两个或两个以上进程在执行过程中，因为资源竞争问题等而形成阻塞的现象，如果外部不施以干预，死锁进程将一直维持阻塞状态。

死锁的四大必要条件

1、互斥
两个或多个进程需要使用两个或多个相同的资源，例如进程一和进程二都需要资源A和资源B。
2、占有且等待
一个进程占用一个资源并等待着其他资源，另一个资源也占用着资源并等待。例如进程一占用资源A等待着B，进程二占用资源B等待A。
3、不可剥夺
进程一旦占用资源，如果不执行完成将不会释放资源。
4、循环等待
进程没有执行完成将一直保持现状。

使用ReentrantLock类

class DeathLockThread extends Thread{
    private Lock lock;
    private Lock lock1;
    public DeathLockThread(Lock lock, Lock lock1) {
        this.lock = lock;
        this.lock1 = lock1;
    }

    @Override
    public void run() {
        try {
            lock1.lock();
            System.out.println("lock1");
            this.sleep(4000);
            lock.lock();
            System.out.println(222);
            lock.unlock();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            lock1.unlock();
        }

    }
}
class DeathLockThread1 extends Thread{
    private Lock lock;
    private Lock lock1;
    public DeathLockThread1(Lock lock, Lock lock1) {
        this.lock = lock;
        this.lock1 = lock1;
    }

    @Override
    public void run() {

        try {
            lock.lock();
            System.out.println("lock");
            this.sleep(4000);
            lock1.lock();
            System.out.println(222);
            lock1.unlock();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            lock.unlock();

        }

    }
}
public class DeathLock {
    private static Lock lock1 = new ReentrantLock();
    private static Lock lock2 = new ReentrantLock();
    public static void main(String[] args) {
        DeathLockThread deathLockThread = new DeathLockThread(lock1,lock2);
        DeathLockThread1 deathLockThread1 = new DeathLockThread1(lock1,lock2);
        deathLockThread.start();
        deathLockThread1.start();
    }
}

使用synchronized关键字

class DeathLockThread extends Thread{


    @Override
    public void run() {

        synchronized (DeathLock.obj1){
            try {
                System.out.println("lock lock d");
                this.sleep(5000);
                synchronized (DeathLock.obj2){
                    System.out.println("lock lock d1");
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
class DeathLockThread1 extends Thread{

   @Override
    public void run() {
        synchronized (DeathLock.obj2){
            try {
                System.out.println("lock1 lock d1");
                this.sleep(4000);
                synchronized (DeathLock.obj1){
                    System.out.println("lock1 lock d");
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
public class DeathLock {
    public static String obj1 = "obj1";
    public static String obj2 = "obj2";
    public static void main(String[] args) {
        DeathLockThread deathLockThread = new DeathLockThread();
        DeathLockThread1 deathLockThread1 = new DeathLockThread1();
        deathLockThread.start();
        deathLockThread1.start();
    }
}