java中线程死锁的出现

之前参加工作时总是听说某某功能出现了死锁,经过简要的询问也算是认识到了死锁.

关于"锁"的出现这里就不再赘述了,它的出现就是实现线程同步,维护数据的唯一性,使得多线程访问共享资源是顺序进行的

那么死锁是什么呢?

我的理解是:所有线程都在等待根本不可能被释放的锁资源,导致工作无法正常进行

下面就来介绍下死锁出现的四个条件↓↓↓↓

①互斥条件：

即当资源被一个线程使用(占有)时，别的线程不能使用

②请求和保持条件：

即当资源请求者在请求其他的资源的同时保持对原有资源的占有

③不剥夺条件：

资源请求者不能强制从资源占有者手中夺取资源，资源只能由资源占有者主动释放

④环路等待条件：

指在发生死锁时，必然存在一个进程——资源的环形链，即进程集合{P0，P1，P2，···，Pn}中的P0正在等待一个P1占用的资源；P1正在等待P2占用的资源，……，Pn正在等待已被P0占用的资源

最近在刷面试题时遇到"手写死锁"的问题,说实话确实无从下手!

一.案例背景:

二.死锁代码及其测试结果展示:

public class DeadLock {
    //定义锁A
    private static final Object cardA = new Object();
    //定义锁B
    private static final Object cardB = new Object();

    /**
     * 穿过A房间进入B房间
     */
    public static void acrossRoomA(){
        synchronized (cardA){
            System.out.println(Thread.currentThread().getName()+"拿到cardA进入了A房间,等待cardB进入B房间....");
            try {
                Thread.sleep(500);
                acrossRoomB();//需要在A房间内穿越到房间B
                System.out.println(Thread.currentThread().getName()+"获得了cardB,顺利进入B房间!");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 穿过B房间进入A房间
     */
    public static void acrossRoomB(){
        synchronized (cardB){
            System.out.println(Thread.currentThread().getName()+"拿到cardB进入了B房间,等待cardA进入A房间....");
            try {
                Thread.sleep(500);
                acrossRoomA();//需要在B房间内穿越到房间A
                System.out.println(Thread.currentThread().getName()+"获得了cardA,顺利进入A房间!");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                acrossRoomA();
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                acrossRoomB();
            }
        }).start();
    }
}

测试结果:

三.死锁检测方式

1.JDK命令行工具jps、jstack

①jps获取当前运行的java进程的pid

②jstack+pid查看死锁

2.使用Idea自带的功能,点击Dump Threads图标

四.死锁的解决办法

这里使用信号量Semaphore(可以自行查阅其API)去控制.

信号量可以控制资源能被多少线程访问，这里我们指定只能被一个线程访问，就做到了类似锁住。而信号量可以指定去获取的超时时间，我们可以根据这个超时时间，去做一个额外处理。

对于无法成功获取的情况，一般就是重复尝试，或指定尝试的次数，也可以马上退出!

package deadlock;

import java.util.concurrent.Semaphore;
import java.util.concurrent.TimeUnit;

public class DeadLockSolution {

    //定义2个信号量
    public static final Semaphore licenceA = new Semaphore(1);
    //同一个时刻，只运行多少个进程同时运行指定代码
    public static final Semaphore licenceB = new Semaphore(1);

    /**
     * 穿过A房间进入B房间
     */
    public static void acrossRoomA() {
        try {
            if (licenceA.tryAcquire(1,TimeUnit.SECONDS)){
                System.out.println(Thread.currentThread().getName()+"获得A房间许可并进入,等待获取进入B房间许可....");
                Thread.sleep(500);
                acrossRoomB();//需要在A房间内穿越到房间B
                System.out.println(Thread.currentThread().getName()+"获得B房间许可,顺利进入B房间!");
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            licenceA.release();//释放A房间许可
        }
    }

    /**
     * 穿过B房间进入A房间
     */
    public static void acrossRoomB() {
        try {
            if (licenceB.tryAcquire(1,TimeUnit.SECONDS)){
                System.out.println(Thread.currentThread().getName()+"获得B房间许可并进入,等待获取进入A房间许可....");
                Thread.sleep(500);
                acrossRoomA();//需要在B房间内穿越到房间A
                System.out.println(Thread.currentThread().getName()+"获得A房间许可,顺利进入A房间!");
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            licenceB.release();//释放B房间许可
        }
    }

    public static void main(String[] args) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                acrossRoomA();
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                acrossRoomB();
            }
        }).start();
    }
}

测试结果:

Thread-0获得A房间许可并进入,等待获取进入B房间许可....
Thread-1获得B房间许可并进入,等待获取进入A房间许可....
Thread-1获得A房间许可,顺利进入A房间!
Thread-0获得B房间许可,顺利进入B房间!