多线程--解决死锁问题

参考：https://www.cnblogs.com/Andrew520/p/12093320.html

产生原因：

java 死锁产生的四个必要条件：
1>互斥使用，即当资源被一个线程使用(占有)时，别的线程不能使用
2>不可抢占，资源请求者不能强制从资源占有者手中夺取资源，资源只能由资源占有者主动释放。
3>请求和保持，即当资源请求者在请求其他的资源的同时保持对原有资源的战友。
4>循环等待，即存在一个等待队列：P1占有P2的资源，P2占有P3的资源，P3占有P1的资源。这样就形成了一个等待环路。

简单来说，就是两个线程，都拿到对方的锁，向对方要自己的锁，然后都不释放锁
嵌套的用锁造成的死锁！！！！！

测试：
线程Thread-1拿到obj2锁准备去拿obj1锁…
线程Thread-0拿到obj1锁准备去拿obj2锁…
然后Thread-1和Thread-0都没有释放自己的锁(由于自己锁里面的任务还没有完成！！)，所以双方最后都卡在要对方锁的情况下！！！！

package com.example.dtest.killLock.test;

import java.util.Date;

public class LockTest {

    public static  String obj1 = "obj1";
    public static  String obj2 = "obj2";

    public static void main(String[] args) {

        LockA la = new LockA();
        new Thread(la).start();
        LockB lb = new LockB();
        new Thread(lb).start();


    }

 static class LockA implements Runnable{

        @Override
        public void run() {

            try {

                System.out.println(new Date().toString() + "LockA 开始执行");
                while (true){

                    synchronized (LockTest.obj1){
                        System.out.println("线程"+Thread.currentThread().getName()+"拿到obj1锁");
                        System.out.println(new Date().toString() + " LockA 锁住 obj1");
                        System.out.println("线程"+Thread.currentThread().getName()+"准备去拿obj2锁....");
                        Thread.sleep(3000); // 此处等待是给B能锁住机会
//                        这里去拿obj2的锁，因为obj2刺客的锁被LockB拿到了，所以就卡在这里，形成死锁了
                        synchronized (LockTest.obj2) {
                            System.out.println("线程"+Thread.currentThread().getName()+"拿到obj2锁");
                            System.out.println(new Date().toString() + " LockA 锁住 obj2");
                            Thread.sleep(60 * 1000); // 为测试，占用了就不放
                        }


                    }

                }
            }catch (Exception e){
                e.printStackTrace();
            }

        }
    }

    static class  LockB implements  Runnable{

    @Override
    public void run() {
        try {
            System.out.println(new Date().toString() + " LockB 开始执行");
            while(true){
                synchronized (LockTest.obj2) {
                    System.out.println("线程"+Thread.currentThread().getName()+"拿到obj2锁");
                    System.out.println(new Date().toString() + " LockB 锁住 obj2");
                    System.out.println("线程"+Thread.currentThread().getName()+"准备去拿obj1锁....");
                    Thread.sleep(3000); // 此处等待是给A能锁住机会

//                        这里去拿obj1的锁，因为obj1刺客的锁被LockA拿到了，所以就卡在这里，形成死锁了
                    synchronized (LockTest.obj1) {
                        System.out.println("线程"+Thread.currentThread().getName()+"拿到obj1锁");
                        System.out.println(new Date().toString() + " LockB 锁住 obj1");
                        Thread.sleep(60 * 1000); // 为测试，占用了就不放
                    }
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}




}

解决方案：

我们不使用显示的去锁，我们用信号量去控制。

1、使用Semaphore解决,但是释放锁时不能判断时该线程持有的锁从而释放对应的锁，所以最好的解决方案时使用Lock：

信号量可以控制资源能被多少线程访问，这里我们指定只能被一个线程访问，就做到了类似锁住。而信号量可以指定去获取的超时时间，我们可以根据这个超时时间，去做一个额外处理。
对于无法成功获取的情况，一般就是重复尝试，或指定尝试的次数，也可以马上退出。

使用信号灯Semaphore可以得到是否获令牌锁的返回值，可以设置获取时间，超过了就结束尝试获取令牌并返回false

并使用release()方法释放锁

package com.example.dtest.killLock.test;

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

public class LockTest02 {

    public static final Semaphore a1 = new Semaphore(1);
    public static final Semaphore a2 = new Semaphore(1);

    public static void main(String[] args) {

        LockAa la = new LockAa();
        new Thread(la).start();
        LockBb lb = new LockBb();
        new Thread(lb).start();

    }

    static  class LockAa implements Runnable{

        @Override
        public void run() {

            try {
            System.out.println(new Date().toString() + " LockA 开始执行");
            while (true) {
//          使用信号灯Semaphore可以得到是否获令牌锁的返回值，可以设置获取时间，超过了就结束尝试获取令牌并返回false
                System.out.println(Thread.currentThread().getName()+"尝试获取a1信号令牌");
                if (LockTest02.a1.tryAcquire(1, TimeUnit.SECONDS)) {
                    System.out.println(Thread.currentThread().getName()+"获取a1信号令牌--成功！！");
                    System.out.println(new Date().toString() + " LockA 锁住 obj1");
                    System.out.println(Thread.currentThread().getName()+"尝试获取--a2信号令牌");
                    if (LockTest02.a2.tryAcquire(1, TimeUnit.SECONDS)) {
                        System.out.println(Thread.currentThread().getName()+"获取--a2信号令牌成功！！");
                        System.out.println(new Date().toString() + " LockA 锁住 obj2");
                        Thread.sleep(60 * 1000); // do something
                    }else{
                        System.out.println(Thread.currentThread().getName()+"尝试获取a2信号令牌--失败");
                        System.out.println(new Date().toString() + "LockA 锁 obj2 失败");
                    }
                }else{
                    System.out.println(Thread.currentThread().getName()+"尝试获取a1信号令牌--失败");
                    System.out.println(new Date().toString() + "LockA 锁 obj1 失败");
                }
                LockTest02.a1.release(); // 释放
                LockTest02.a2.release();
                Thread.sleep(1000); // 马上进行尝试，现实情况下do something是不确定的
            }
        } catch (Exception e) {
            e.printStackTrace();
        }

        }
    }

    static class LockBb implements  Runnable{

        @Override
        public void run() {

            try {
                System.out.println(new Date().toString() + " LockB 开始执行");
                while (true) {
                    System.out.println(Thread.currentThread().getName()+"尝试获取a2信号令牌");
                    if (LockTest02.a2.tryAcquire(1, TimeUnit.SECONDS)) {
                        System.out.println(Thread.currentThread().getName()+"获取a2信号令牌--成功！！");
                        System.out.println(new Date().toString() + " LockB 锁住 obj2");
                        System.out.println(Thread.currentThread().getName()+"获取a1信号令牌");
                        if (LockTest02.a1.tryAcquire(1, TimeUnit.SECONDS)) {
                            System.out.println(Thread.currentThread().getName()+"获取a1信号令牌--成功！！");
                            System.out.println(new Date().toString() + " LockB 锁住 obj1");
                            Thread.sleep(60 * 1000); // do something
                        }else{
                            System.out.println(Thread.currentThread().getName()+"获取a2信号令牌--失败！！");
                            System.out.println(new Date().toString() + "LockB 锁 obj1 失败");
                        }
                    }else{
                        System.out.println(Thread.currentThread().getName()+"获取a2信号令牌--失败！！");
                        System.out.println(new Date().toString() + "LockB 锁 obj2 失败");
                    }
                    LockTest02.a1.release(); // 释放
                    LockTest02.a2.release();
                    Thread.sleep(10 * 1000); // 这里只是为了演示，所以tryAcquire只用1秒，而且B要给A让出能执行的时间，否则两个永远是死锁
                }
            } catch (Exception e) {
                e.printStackTrace();
            }

        }

    }




}

这样可以看到，当有一个线程获取不到令牌锁后，他会谦让（因为一段时间后，Semaphore就返回false放弃在去获取令牌锁），这样就可以让该线程执行到释放锁的程序，然后另外一个线程就可以获取该线程的令牌锁了！！

2、使用lock解决(并且在释放锁时能判断是哪个线程持有的该锁)

采用lock锁使用trylock 获取锁，并使用unlock释放锁采用flag控制循环的结束
也有和Semaphore相同功能的方法！！
tryLock(long time, TimeUnit unit)方法和tryLock()方法是类似的，只不过区别在于这个方法在拿不到锁时会等待一定的时间，在时间期限之内如果还拿不到锁，就返回false。如果如果一开始拿到锁或者在等待期间内拿到了锁，则返回true。

1、lock.isFair()方法用来判断lock锁是公平锁还是非公平锁。公平锁是指，线程获得锁的顺序是按其等待锁的先后顺序来的，先来先获得FIFO。反之，非公平锁则是线程随机获得锁的，lock默认是非公平锁。

2、lock.isHeldByCurrentThread()的作用是查询当前线程是否保持此锁定（就是当前线程是否持有该锁），和lock.hasQueueThread()不同的地方是：lock.hasQueueThread(Thread thread)的作用是判断当前线程是否处于等待lock的状态。

3、lock.isLocked()的作用是查询此锁定是否由任意线程保持。

这里使用boolean fa = true;这个参数来控制循环是否继续

package com.example.dtest.killLock.test;

import java.util.Date;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReentrantLock;

public class LockTest03 {

    public static ReentrantLock lock1 = new ReentrantLock();
    public static ReentrantLock lock2 = new ReentrantLock();

    public static void main(String[] args) {

        Thread t1 = new Thread(new LockA(),"线程A");
        Thread t2 = new Thread(new LockB(),"线程B");

        t1.start();
        t2.start();
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("主线程结束");

    }

    static class LockA implements Runnable{

        boolean fa = true;

        @Override
        public void run() {

            System.out.println("线程A开始执行"+new Date());
            try {
                while (fa){
                    System.out.println(Thread.currentThread().getName()+"尝试获取lock1的锁");
                    if (LockTest03.lock1.tryLock(1, TimeUnit.SECONDS)){
                        System.out.println(Thread.currentThread().getName()+"获取lock1的锁--成功！！");
                        System.out.println("线程A锁住lock1"+new Date());
                        System.out.println(Thread.currentThread().getName()+"尝试获取lock2的锁");
                        if (LockTest03.lock2.tryLock(1,TimeUnit.SECONDS)){
                            System.out.println(Thread.currentThread().getName()+"获取lock2的锁--成功！！");
                            System.out.println("线程A锁住lock2"+new Date());
//                            如果获取到了锁，就执行后推出循环
                            fa =false;
                        }else {
                            System.out.println(Thread.currentThread().getName()+"尝试获取lock2的锁--失败");
                            System.out.println("线程A锁住lock2 失败"+new Date());
                        }
                    }else {
                        System.out.println(Thread.currentThread().getName()+"尝试获取lock1的锁--失败");
                        System.out.println("线程A锁住lock1 失败"+new Date());
                    }

                  
                    System.out.println("当前线程"+Thread.currentThread().getName());
                    if (lock1.isHeldByCurrentThread()){
                        System.out.println(Thread.currentThread().getName()+"持有lock1的锁");
                        lock1.unlock();
                        System.out.println("线程A释放lock1");
                    }
                    if (lock2.isHeldByCurrentThread()){
                        System.out.println(Thread.currentThread().getName()+"持有lock2的锁");
                        lock2.unlock();
                        System.out.println("线程A释放lock2");
                    }
                    Thread.sleep(2000);
                }
                System.out.println("线程A结束=============");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        }
    }

    static class  LockB implements  Runnable{
        boolean fb = true;

        @Override
        public void run() {
            System.out.println("线程B开始执行"+new Date());
            try {
                while (fb){
                    System.out.println(Thread.currentThread().getName()+"尝试获取lock2的锁");
                    if (LockTest03.lock2.tryLock(1,TimeUnit.SECONDS)){
                        System.out.println(Thread.currentThread().getName()+"获取lock2的锁--成功！！");
                        System.out.println("线程B锁住lock2"+new Date());
                        System.out.println(Thread.currentThread().getName()+"尝试获取lock1的锁");
                        if (LockTest03.lock1.tryLock(1,TimeUnit.SECONDS)){
                            System.out.println(Thread.currentThread().getName()+"获取lock1的锁--成功！！");
                            System.out.println("线程B锁住lock1"+new Date());
                            //                            如果获取到了锁，就执行后推出循环
                            fb=false;
                        }else {
                            System.out.println(Thread.currentThread().getName()+"尝试获取lock1的锁--失败");
                            System.out.println("线程B锁住lock1 失败"+new Date());
                        }
                    }else {
                        System.out.println(Thread.currentThread().getName()+"尝试获取lock2的锁--失败");
                        System.out.println("线程B锁住lock2 失败"+new Date());
                    }
                
                    System.out.println("当前线程"+Thread.currentThread().getName());
                    if (lock1.isHeldByCurrentThread()){
                        System.out.println(Thread.currentThread().getName()+"持有lock1的锁");
                        lock1.unlock();
                        System.out.println("线程B释放lock1");
                    }
                    if (lock2.isHeldByCurrentThread()){
                        System.out.println(Thread.currentThread().getName()+"持有lock2的锁");
                        lock2.unlock();
                        System.out.println("线程B释放lock2");
                    }
                    Thread.sleep(2000);
                }
                System.out.println("线程结束B=============");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }


}

当两个锁都推出循环时（就是拿到了另外一个线程的锁执行完了该锁中的业务时），就结束了该线程！！

多线程--解决死锁问题

Java相关栏目本月热门文章