线程死锁产生的原因及解决

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

产生死锁的原因：
（1） 因为系统资源不足。
（2） 进程运行推进的顺序不合适。
（3） 资源分配不当等。
总结来说，就是两段不同的逻辑都在等待对方的锁释放才能执行下去，这个时候就产生了死锁
产生死锁的四个必要条件：
（1） 互斥条件：一个资源每次只能被一个进程使用。
（2） 请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放。
（3） 不剥夺条件:进程已获得的资源，在末使用完之前，不能强行剥夺。
（4） 循环等待条件:若干进程之间形成一种头尾相接的循环等待资源关系。
死锁的代码演示

package com.quincy.java.base.deadlock;

public class DeadLockDriver {

    public static void main(String[] args) {

        DeadLockDemo task1 = new DeadLockDemo( true);
        DeadLockDemo task2 = new DeadLockDemo( false);

        Thread t1 = new Thread(task1);
        Thread t2 = new Thread(task2);

        t1.start();
        t2.start();
    }
}

class DeadLockDemo  implements Runnable{
    private boolean flag ;
    public DeadLockDemo( boolean flag){
        this. flag = flag;
    }

    @Override
    public void run() {
        if( flag){
            synchronized (MyLock. LOCKA) {
                System. out.println( "LOCKA=====>LOCKB");
                synchronized (MyLock. LOCKB) {
                    System. out.println( "LOCKA=LOCKB");
                }
            }
        } else{
            synchronized (MyLock. LOCKB) {
                System. out.println( "LOCKB=====>LOCKA");
                synchronized (MyLock. LOCKA) {
                    System. out.println( "LOCKB=LOCKA");
                }
            }
        }
    }
}

class MyLock{
    public  static final Object LOCKA = new Object();
    public static final Object LOCKB = new Object();
}

死锁的查找
可以使用JConsole工具来查找死锁（有兴趣的可以自己去学习）
死锁的解决
使用ReentrantLock锁来解决，ReentrantLock能实现线程公平获取锁的功能，所谓的公平，指的是在申请获取锁的队列中，排在前面的线程总是优先获得需要的锁，与Synchronized不同的是，Synchronized同步获得锁的方式是非公平的，举个例子，线程A和B都尝试获得C持有的锁，当C释放该锁时，A和B谁能获得该锁是不确定的，也就是非公平的，而ReentrantLock提供公平地，即先来后到地获取锁的方式；ReentrantLock锁来解决死锁具体代码如下：

package com.quincy.java.base.deadlock;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class UnDeadLockDriver {
    public static void main(String[] args) {

        UnDeadLockDemo task1 = new UnDeadLockDemo( true);
        UnDeadLockDemo task2 = new UnDeadLockDemo( false);

        Thread t1 = new Thread(task1);
        Thread t2 = new Thread(task2);

        t1.start();
        t2.start();
    }
}

class UnDeadLockDemo implements Runnable{
    Lock lock=new ReentrantLock(true);//公平锁
    private boolean flag ;
    public UnDeadLockDemo( boolean flag){
        this. flag = flag;
    }

    @Override
    public void run() {
        while (true){
            if( flag){
                threadA();
            } else{
                threadB();
            }
        }
    }

    public void threadA(){
        try {
            lock.lock();
            System.out.println("线程A获取锁");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
            System.out.println("线程A释放锁");
        }
    }

    public void threadB(){
        try {
            lock.lock();
            System.out.println("线程B获取锁");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
            System.out.println("线程B释放锁");
        }
    }
}