对Java中各种锁的理解及死锁排查_java reentrantlock 排查死锁

1.公平锁、非公平锁

Synchronized非公平锁，Lock可以自己设置公平or非公平。
默认非公平。
java Lock lock=new ReentrantLock(true);

（公平锁）一群人排队上厕所。
**优点：**所有人都能上厕所，等着就完了。
**缺点：**所有人都要站在厕所门口排队（所有线程唤醒CPU开销大）。

（非公平锁）一群人抢着上厕所，抢不到就等下次再抢。
**优点：**不用大家排队（没必要所有线程都唤醒CPU开销小）前一个线程执行完了随机给一个人发消息说可以来上厕所了notify，前一个线程执行完了给所有人发消息说可以来上厕所了，然后一群人抢notifyall。
**缺点：**总抢不到的人容易拉裤子里。

2.可重入锁，递归锁

拿到外面的锁，就可以拿到里面的锁，自动获得。
无论如何执行结果都是
AA AB BA BB

public class LockTest {
    public static void main(String[] args){

        new Thread(()->{
            A();
        },"A").start();

        new Thread(()->{
            A();
        },"B").start();

    }
    public static synchronized void A(){
        System.out.println(Thread.currentThread().getName()+"A");
        B();
    }
    public static synchronized void B(){
        System.out.println(Thread.currentThread().getName()+"B");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

ReentrantLock版本，同理

import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicStampedReference;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class LockTest2{
    public static void main(String[] args){

        new Thread(()->{
            A();
        },"A").start();

        new Thread(()->{
            A();
        },"B").start();

    }
    static Lock lock=new ReentrantLock();
    public static void A(){
        lock.lock(); //拿到第一把锁 锁必须配对
        System.out.println(Thread.currentThread().getName()+"A");
        B();//拿到第二把锁
        lock.unlock();
    }
    public static void B(){
        lock.lock();
        System.out.println(Thread.currentThread().getName()+"B");
        lock.unlock();
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

3.自旋锁

不断循环自身，直到成功为止。例如，GetAndAddInt不断使用CAS进行比较。
核心：while

class Self {
   AtomicReference<Thread> atomicReference=new AtomicReference<>();
   public void myLock(){
       Thread thread=Thread.currentThread();
       System.out.println(thread.getName()+"自旋");
       //自旋锁
       while(!atomicReference.compareAndSet(null,thread)){

       }
    }
    public void myUnLock(){
        Thread thread=Thread.currentThread();
        System.out.println(thread.getName()+"解锁");
        atomicReference.compareAndSet(thread,null);
    }
}
public class test{
    public static void main(String[] args) {
        Self self=new Self();
        new Thread(()->{
            self.myLock();
            self.myUnLock();
        },"T1").start();
        new Thread(()->{
            self.myLock();
            self.myUnLock();
        },"T2").start();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

4.死锁

A持有A锁，等待获取B锁。
B持有B锁，等待获取A锁。
二者均不能释放锁，也不能强行剥夺锁。

1、互斥条件：一个资源每次只能被一个进程使用；
2、请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放；
3、不剥夺条件:进程已获得的资源，在末使用完之前，不能强行剥夺；
4、循环等待条件:若干进程之间形成一种头尾相接的循环等待资源关系；

import java.util.concurrent.TimeUnit;

class A implements Runnable{
    private String lockA;
    private String lockB;

    public A(String lockA,String lockB){
        this.lockA=lockA;
        this.lockB=lockB;
    }
    @Override
    public void run() {
        synchronized (lockA){
            System.out.println(Thread.currentThread().getName()+"lock:"+lockA+"-get:"+lockB);
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (lockB){
                System.out.println(Thread.currentThread().getName()+"lock:"+lockB+"-get:"+lockA);
            }
        }
    }
}
public class MyThread1{
    public static void main(String[] args) {
        String lockA="lockA";
        String lockB="lockB";
        new Thread((new A(lockA,lockB))).start();
        new Thread((new A(lockB,lockA))).start();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

解决方法：
查看日志，查看堆栈信息
使用JPS定位进程号：jps -l
使用JSTACK找到该进程查看堆栈信息：jstack 15936（Found 1 deadlock.）

排查代码，最后破坏死锁条件。