并发操作之——手写死锁实战

并发操作

并发操作之——手写死锁实战

---

---

一、死锁代码实战

死锁： 线程在获得了锁A并且没有释放的情况下去申请锁B，
这时另一个线程已经获得了锁B，在释放锁B之前又要先获得锁A
因此闭环发生，陷入死锁循环

package net.xdclass.xdclasssp.lock;

/**
 * @author Cym
 * @date 2021/9/7
 */
public class DeadLockDemo {

    private static final String lockA = "锁A";

    private static final String lockB = "锁B";

    private void methodA() {

        synchronized (lockA) {
            System.out.println("我是A方法中获得了锁A" + Thread.currentThread().getName());

            //让出CPU执行权，不释放锁
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (lockB) {
                System.out.println("我是A方法中获得了锁B" + Thread.currentThread().getName());
            }
        }

    }


    private void methodB() {

        synchronized (lockB) {
            System.out.println("我是B方法中获得了锁B" + Thread.currentThread().getName());

            //让出CPU执行权，不释放锁
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (lockA) {
                System.out.println("我是B方法中获得了锁A" + Thread.currentThread().getName());
            }
        }
    }

    public static void main(String[] args) {

        System.out.println("主线程开始运行" + Thread.currentThread().getName());

        DeadLockDemo deadLockDemo = new DeadLockDemo();

        new Thread(() -> {
            deadLockDemo.methodA();
        }).start();

        new Thread(() -> {
            deadLockDemo.methodB();
        }).start();

        System.out.println("主线程结束运行" + Thread.currentThread().getName());

    }

}

二、死锁的四个必要条件

1、互斥条件

资源不能共享，只能由一个线程使用

2、请求与保持条件

线程已经获得一些资源，但因请求其他资源发生阻塞，对已经获得的资源保持不释放

3、不可抢占

有些资源是不可强占的，当某个线程获得这个资源后，系统不能强行回收，只能由线程使用完自己释放

4、循环等待条件

多个线程形成环形链，每个都占用对方申请的下个资源
​
只要发生死锁，上面的条件都成立；只要一个不满足，就不会发生死锁

三、死锁的解决办法，以及上面死锁的代码优化

常见的解决办法：
1、调整申请锁的范围
2、调整申请锁的顺序
示例代码：调整锁的申请范围

package net.xdclass.xdclasssp.lock;

/**
 * @author Cym
 * @date 2021/9/7
 */
public class DeadLockDemo {

    private static final String lockA = "锁A";

    private static final String lockB = "锁B";

    private void methodA() {

        synchronized (lockA) {
            System.out.println("我是A方法中获得了锁A" + Thread.currentThread().getName());

            //让出CPU执行权，不释放锁
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        synchronized (lockB) {
            System.out.println("我是A方法中获得了锁B" + Thread.currentThread().getName());
        }
    }


    private void methodB() {

        synchronized (lockB) {
            System.out.println("我是B方法中获得了锁B" + Thread.currentThread().getName());

            //让出CPU执行权，不释放锁
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        synchronized (lockA) {
            System.out.println("我是B方法中获得了锁A" + Thread.currentThread().getName());
        }
    }

    public static void main(String[] args) {

        System.out.println("主线程开始运行" + Thread.currentThread().getName());

        DeadLockDemo deadLockDemo = new DeadLockDemo();

        new Thread(() -> {
            deadLockDemo.methodA();
        }).start();

        new Thread(() -> {
            deadLockDemo.methodB();
        }).start();

        System.out.println("主线程结束运行" + Thread.currentThread().getName());

    }

}

---

总结

死锁实战。