JUC-多线程锁

1.可重入锁，可重入锁有
synchronized、ReentrantLock
某个线程已经获得某个锁，可以再次获取锁而不会出现死锁
public class WhatReentrant {

    public static void main(String[] args) {

        new Thread(() -> {
            synchronized (WhatReentrant.class) {
                System.out.println("第1次获取synchronized锁");
                for (int i = 2; i <= 5; i++) {
                    synchronized (WhatReentrant.class) {
                        System.out.println("第" + i + "次获取synchronized锁");
                    }
                }
            }
        }, "A").start();

        ReentrantLock lock = new ReentrantLock();
        new Thread(() -> {
            try {
                lock.lock();
                System.out.println("第1次获取ReentrantLock锁");
                for (int i = 2; i <= 5; i++) {
                    try {
                        lock.lock();
                        System.out.println("第" + i + "次获取ReentrantLock锁");
                    } catch (Exception e) {
                        lock.unlock();
                        e.printStackTrace();
                    }
                }
            } catch (Exception e) {
                lock.unlock();
                e.printStackTrace();
            }
        }, "B").start();

    }
}

2.公平锁 VS 非公平锁(公平锁遵循FIFO原则) 
ReentrantLock、ReadWriteLock默认都是非公平锁
参考：https://www.cnblogs.com/heyouxin/p/13037146.html

public ReentrantLock() {
    sync = new NonfairSync();
// 默认非公平锁
}
public ReentrantLock(boolean fair) {
    sync = fair ? new FairSync() : new NonfairSync();
}
公平锁与非公平锁有什么区别？
非公平锁，当前锁占用状态=0直接会进行compareAndSetState尝试获取锁
公平锁，当前锁占用状态=0后，会继续判断hasQueuedPredecessors，即当前队列是否有排队的情况，如果没有才会尝试获取锁

非公平锁的效率为什么会高于公平锁？
可以直接compareAndSetState来获取锁，不需要加入队列然后等待队列头线程唤醒再获取锁这一步骤，所以效率较快

3.死锁
public class DeadLock {

    public static void main(String[] args) {
        Object a = new Object();
        Object b = new Object();

        new Thread(()-> {
            synchronized (a){
                System.out.println("获取到锁a,等待获取锁b~");
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (b){
                    System.out.println("获取到锁b~");
                }

            }
        },"A").start();
        new Thread(()-> {
            synchronized (b){
                System.out.println("获取到锁b,等待获取锁a~");
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (a){
                    System.out.println("获取到锁a~");
                }

            }
        },"B").start();

    }
}

检查死锁
jps -l 
jstack 进程号