Java多线程产生死锁

目录

一、死锁

二、死锁举例

三、避免死锁

---

一、死锁

死锁： 线程等待某个资源，导致线程被无限期地阻塞

二、死锁举例

例如：不适当地运用“synchronized”关键词。如果线程A锁住strA ，线程B锁住strB，线程A就没办法锁住strB，线程B也没办法锁住strA，这个时候就陷入了死锁

例子原地址：

public class Test {
 4     public static String objA = "strA";
 5     public static String objB = "strB";
 6     public static void main(String[] args){
 7         Thread a = new Thread(new Lock1());
 8         Thread b = new Thread(new Lock2());
 9         a.start();
10         b.start();
11     }    
12 }
13 class Lock1 implements Runnable{
14     @Override
15     public void run(){
16         try{
17             System.out.println("Lock1 running");
18             while(true){
19                 synchronized(Test.objA){
20                     System.out.println("Lock1 lock strA");
21                     Thread.sleep(3000);//获取strA后先等一会儿，让Lock2有足够的时间锁住strB
22                     synchronized(Test.objB){
23                         System.out.println("Lock1 lock strB");
24                     }
25                 }
26             }
27         }catch(Exception e){
28             e.printStackTrace();
29         }
30     }
31 }
32 class Lock2 implements Runnable{
33     @Override
34     public void run(){
35         try{
36             System.out.println("Lock2 running");
37             while(true){
38                 synchronized(Test.objB){
39                     System.out.println("Lock2 lock strB");
40                     Thread.sleep(3000);
41                     synchronized(Test.objA){
42                         System.out.println("Lock2 lock strA");
43                     }
44                 }
45             }
46         }catch(Exception e){
47             e.printStackTrace();
48         }
49     }
50 }

多线程之死锁_两个线程构造死锁_多则惑少则明的博客-CSDN博客死锁产生原因 当两个或者多个线程互相持有一定资源，并互相等待其他线程释放资源而形成的一种僵局，就是死锁。例如：一个线程持有A资源，希望使用B资源，而另一个线程持有B资源，希望使用A资源，然后就陷入了相互等待的僵局，这样就形成了死锁。 多个线程涉及到多个锁，这些锁存在着交叉，所以可能会导致了一个锁依赖的闭环。代码构造死锁场景public class ...https://blog.csdn.net/huazhongkejidaxuezpp/article/details/88984132?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522168388597616800188523860%2522%252C%2522scm%2522%253A%252220140713.130102334.pc%255Fblog.%2522%257D&request_id=168388597616800188523860&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2~blog~first_rank_ecpm_v1~rank_v31_ecpm-1-88984132-null-null.blog_rank_default&utm_term=%E4%B8%AA%E7%BA%BF%E7%A8%8B%E5%AE%89%E5%85%A8%E7%9A%84%E5%8D%95%E4%BE%8B%E6%A8%A1%E5%9E%8B&spm=1018.2226.3001.4450

三、lock

ReentrantLock 类实现了 Lock，它拥有与 synchronized 相同的并发性和内存语义，在实现线程安全的控制中，比较常见的是 ReentrantLock，可以显式加锁，释放锁；

class Test{
    private final ReentrantLock lock = new ReentrantLock();
    public void method(){
        lock.lock();
        try{
            //保证线程安全的代码
        }finally{
            lock.unlock();
            //如果同步代码有异常，要将unlock()写入finally语句块
        }
    }
}
 

四、synchronized 与 Lock 的对比

Lock是显示锁（手动开启和关闭锁，别忘记关锁）synchronized是隐式锁，出了作用域自动释放；
Lock只有代码块锁，synchronized有代码块锁和方法锁；
使用 Lock锁，JVM将花费较少的时间来调度线程，性能更好，且具有更好的扩展性（提供更多的子类）；
优先使用顺序：
Lock > 同步代码块(已经进入方法体，分配了相应资源) > 同步方法（在方法体之外）
 

五、避免死锁

1、尽量不要在锁里又加锁

2、获取锁时，一旦获取不到，就释放锁，随机等待一段时间后，再获取；

3、按照顺序加锁是一种有效的死锁预防机制。但是，这种方式需要你事先知道所有可能会用到的锁