Java中多线程详解（2）产生死锁缘由及解决方法

时间 2021-04-10

标签多线程 ide post 学习 spa 线程 code 视频对象教程栏目 Java 繁體版

原文原文链接

1、什么是死锁多线程

死锁理解起来很简单，就是一个字，堵，下面图中拥堵的十字路口就能够看作一个死锁的状态，四个方向的车都要往前走，可是十字路口只有一个，只能容许一个方向的车经过后，才能让另外一个方向的车经过。ide

在多线程中，四个方向的车流就能够看作4个线程，而十字路口能够看作一个资源对象，四个线程都要占有它，会致使程序没法正常的运行，这就叫死锁，是否是很容易理解呢。post

用比较官方的解释死锁的话，就是经典的四大条件学习

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

二、不可抢占，资源请求者不能强制从资源占有者手中夺取资源，资源只能由资源占有者主动释放。线程

三、请求和保持，即当资源请求者在请求其余的资源的同时保持对原有资源的占有。code

四、循环等待，即存在一个等待队列：P1占有P2的资源，P2占有P3的资源，P3占有P1的资源。这样就造成了一个等待环路。视频

当上述四个条件都成立的时候，便造成死锁。固然，死锁的状况下若是打破上述任何一个条件，即可让死锁消失。对象

2、建立死锁案例教程

public class DeadLock {
    public static String r1="r1";
    public static String r2="r2";
    public static void main(String[] args) {
        Runable1 runable1=new Runable1();
        Runable2 runable2=new Runable2();
        Thread thread1=new Thread(runable1);
        Thread thread2=new Thread(runable2);
        thread1.start();
        thread2.start();
    }
}
class Runable1 implements Runnable{
    @Override
    public void run() {
        try {
             (DeadLock.r1) {
                System.out.println("r1的synchronized锁住r1");
                Thread.sleep(3000);
                synchronized (DeadLock.r2) {
                    System.out.println("拿不到r2略略略");
                    Thread.sleep(60 * 1000);
                }
                System.out.println("被锁住了，没法打印");
            }
        }catch (Exception e) {
            e.printStackTrace();
        }
    }
}
class Runable2 implements Runnable{
    @Override
    public void run() {
        try {
            synchronized (DeadLock.r2){
                System.out.println("synchronized锁住r2");
                Thread.sleep(3000);
                synchronized (DeadLock.r1){
                    System.out.println("拿不到r1略略略");
                    Thread.sleep(60 * 1000);
                }
                System.out.println("被锁住了，没法打印");
            }
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}
//运行结果
r1的synchronized锁住r1
synchronized锁住r2
复制代码

在上面这个案例中，先建立了两个资源对象r1和r2,而后建立了两个线程类Runable1和Runable2，用synchronized方法去给资源添加锁，使得两个线程在执行完run方法以前都不会释放资源对象r1和r2，（synchronized方法的做用就是一个同步锁，代码中放入synchronized括号中的资源在线程结束前都不会释放，也就不能被其余线程使用）以后用sleep方法让线程阻塞（sleep（3000）的做用是是给线程能锁住机会，sleep（60*1000）的做用是让线程阻塞），这样就形成了死锁的现象，致使后面的语句没法打印出来。

3、如何解决死锁问题

1.在写多线程操做时，最好不要一次锁定多个对象，这样就不会致使死锁了。修改后的代码以下。

public class DeadLock {
    public static String r1="r1";
    public static String r2="r2";
    public static void main(String[] args) {
        Runable1 runable1=new Runable1();
        Runable2 runable2=new Runable2();
        Thread thread1=new Thread(runable1);
        Thread thread2=new Thread(runable2);
        thread1.start();
        thread2.start();
    }
}
class Runable1 implements Runnable{
    @Override
    public void run() {
        try {
            synchronized (DeadLock.r1) {
                System.out.println("r1的synchronized锁住r1");
                Thread.sleep(3000);
                    System.out.println("拿到r2");
                    Thread.sleep(3000);
                System.out.println("解锁了，能够打印");
            }
        }catch (Exception e) {
            e.printStackTrace();
        }
    }
}
class Runable2 implements Runnable{
    @Override
    public void run() {
        try {
            synchronized (DeadLock.r2){
                System.out.println("synchronized锁住r2");
                Thread.sleep(3000); 
                   System.out.println("拿到r1");
                    Thread.sleep(3000);
                System.out.println("解锁了，能够打印");
            }
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}
//运行结果
r1的synchronized锁住r1
synchronized锁住r2
拿到r2
拿到r1
解锁了，能够打印
解锁了，能够打印
复制代码

2.若是业务场景须要一次锁定多个资源对象，能够根据资源的某个属性或者hashCode值来作比较，定义锁的前后顺序，下面是一个经过hashCode来定义锁前后顺序的例子。

public class DeadLock {
    public static String r1="r1";
    public static String r2="r2";
    public static void main(String[] args) {
        Runable1 runable1=new Runable1();
        Runable2 runable2=new Runable2();
        Thread thread1=new Thread(runable1);
        Thread thread2=new Thread(runable2);
        thread1.start();
        thread2.start();
    }
}
class Runable1 implements Runnable{
    @Override
    public void run() {
        try {
            if (DeadLock.r1.hashCode()>DeadLock.r2.hashCode()) {
                synchronized (DeadLock.r1) {
                    System.out.println("Runable1的synchronized锁住r1");
                    Thread.sleep(3000);
                    synchronized (DeadLock.r2) {
                        System.out.println("Runable1的synchronized锁住r2");
                        Thread.sleep(3000);
                    }
                    System.out.println("解锁了，能够打印");
                }
            }else{
                synchronized (DeadLock.r2) {
                    System.out.println("Runable1的synchronized锁住r1");
                    Thread.sleep(3000);
                    synchronized (DeadLock.r1) {
                        System.out.println("Runable1的synchronized锁住r2");
                        Thread.sleep(3000);
                    }
                    System.out.println("解锁了，能够打印");
                }
            }
        }catch (Exception e) {
            e.printStackTrace();
        }
    }
}
class Runable2 implements Runnable{
    @Override
    public void run() {
        try {
            if (DeadLock.r1.hashCode()<DeadLock.r2.hashCode()) {
                synchronized (DeadLock.r2) {
                    System.out.println("Runable2的synchronized锁住r2");
                    Thread.sleep(3000);
                    synchronized (DeadLock.r1) {
                        System.out.println("Runable2的synchronized锁住r1");
                        Thread.sleep(3000); 
                   }
                    System.out.println("解锁了，能够打印");
                }
            }else{
                synchronized (DeadLock.r1) {
                    System.out.println("Runable2的synchronized锁住r1");
                    Thread.sleep(3000);
                    synchronized (DeadLock.r2) {
                        System.out.println("Runable2的synchronized锁住r2");
                        Thread.sleep(3000);
                    }
                    System.out.println("解锁了，能够打印");
                }
            }
        }catch (Exception e) {
            e.printStackTrace();
        }
    }
}
//运行结果
Runable1的synchronized锁住r1
Runable1的synchronized锁住r2
解锁了，能够打印
Runable2的synchronized锁住r1
Runable2的synchronized锁住r2
解锁了，能够打印