后端面试实现死锁代码

朱雀 2022-05-29 11:35 63阅读 0赞

死锁发生的四个必要条件：

1. 互斥 一个资源在同一个时间只能被一个线程所占有

2. 请求且保持  线程保持自己获取到的资源，并且去请求其他线程所拥有的资源

3. 不可剥夺  线程已经获取得到的资源，不能被其他线程剥夺

4. 循环等待 线程等待另外线程的资源，出现一个线程-资源的循环链

基本实现：

import java.lang.Thread;
    /**
     * @author by csucoderlee
     * @created on 2018 03 22 21:28
     */
    public class DeadLockTest {
    
        public static void main(String[] args) {
    
            Object a = new Object();
            Object b = new Object();
    
    
            new Thread() {
                @Override
                public void run() {
                    synchronized (a) {
                        try {
                            System.out.println(" ----- 线程A 获取到资源 a -----");
                            Thread.sleep(10000);
                        } catch (Exception e) {
                            e.printStackTrace();
                        }
                        synchronized (b) {
                            System.out.println(" ----- 线程A 获取到资源 b -----");
                        }
                    }
                }
            }.start();
    
            new Thread() {
                @Override
                public void run() {
                    synchronized (b) {
                        try {
                            System.out.println(" ----- 线程B 获取到资源 b -----");
                            Thread.sleep(10000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        synchronized (a) {
                            System.out.println(" ----- 线程B 获取到资源 a -----");
                        }
                    }
                }
            }.start();
        }
    }

既然jdk用的1.8，那就来个lambda表达式版本

import java.lang.Thread;
    
    /**
     * @author by csucoderlee
     * @created on 2018 03 22 21:30
     */
    public class DeadLockTest {
    
        public static void main(String[] args) {
    
            Object a = new Object();
            Object b = new Object();
    
    
            Runnable runnable1 = () -> {
                synchronized (a) {
                    try {
                        System.out.println(" ----- 线程A 获取到资源 a -----");
                        Thread.sleep(10000);
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                    synchronized (b) {
                        System.out.println(" ----- 线程A 获取到资源 b -----");
                    }
                }
            };
    
    
            Runnable runnable2 = () -> {
                synchronized (b) {
                    try {
                        System.out.println(" ----- 线程B 获取到资源 b -----");
                        Thread.sleep(10000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    synchronized (a) {
                        System.out.println(" ----- 线程B 获取到资源 a -----");
                    }
                }
            };
    
            new Thread(runnable1).start();
            new Thread(runnable2).start();
    
            //run（）方法还是在主线程中执行
    //        runnable1.run();
    //        runnable2.run();
        }
    }