可重入锁-Reentrant

Reentrant = Re + entrant : 可重复进入

什么叫可重入：线程可以进入任何一个它已经拥有的锁所同步着的代码块。

可重锁作用：防止死锁

常用的可重入锁：

JDK：ReentrantLock (java.util.concurrent.locks.ReentrantLock)

JVM: Synchronize

public class SynchronizeTEst {

    private int a=0;

    // 锁的是当前对象
    public synchronized void add(){
        a++;
        System.out.println("-------: "+a);
        //已获得锁，再调用desr，同一个线程同一把锁， 直接进去。
        decr();
    }

    // 锁的是当前对象
    public synchronized void decr() {
        a--;
        System.out.println("-------: "+a);

    }

    public static void main(String[] args) {
        SynchronizeTEst synchronizeTEst=new SynchronizeTEst();
        synchronizeTEst.add();
        synchronizeTEst.decr();
    }
}

ReentrantLock：

abstract static class Sync extends AbstractQueuedSynchronizer {}

static final class NonfairSync extends Sync {}

static final class FairSync extends Sync {}

（1）抽象类Sync实现了AQS的部分方法；

（2）NonfairSync实现了Sync，主要用于非公平锁的获取；

（3）FairSync实现了Sync，主要用于公平锁的获取。

// true - 公平锁； 按获取锁的顺序排队等待锁
// false -非公平锁（默认）；直接获取锁，不排队
ReentrantLock reentrantLock = new ReentrantLock(true);

eg:

public static void main(String[] args) {
        ReentrantLock lock=new ReentrantLock(true);
        Runnable runnable = ()->{
            try {
                lock.lock();
                for (int i=0;i<10;i++){
                    Thread thread=Thread.currentThread();
                    System.out.println("....:"+thread.getName()+"，out："+ i);
                    //TimeUnit.MILLISECONDS.sleep(200);
                }
            } finally {
                lock.unlock();
            }
        };
        List<Thread> lst=new ArrayList<>();
        //5个线程依次按顺序输出
        for (int i =0 ;i<5;i++){
            lst.add(new Thread(runnable,"T"+i));
        }
        for (int i =0 ;i<5;i++){
            lst.add(new Thread(runnable,"R"+i));
        }
        lst.forEach(e-> e.start());
    }

ReenTrantLock独有的能力：

• ReenTrantLock可以指定是公平锁还是非公平锁。而synchronized只能是非公平锁。所谓的公平锁就是先等待的线程先获得锁。
• ReenTrantLock提供了一个Condition（条件）类，用来实现分组唤醒需要唤醒的线程们，而不是像synchronized要么随机唤醒一个线程要么唤醒全部线程。
• ReenTrantLock提供了一种能够中断等待锁的线程的机制，通过lock.lockInterruptibly()来实现这个机制。

总结

• 可重入锁指的是可重复可递归调用的锁，在外层使用锁之后，在内层仍然可以使用，并且不发生死锁，这样的锁就叫做可重入锁。与可重入锁相反，不可重入锁不可递归调用，递归调用就发生死锁。
• 隐式锁（即synchronized关键字使用的锁）默认是可重入锁，显式锁（即Lock）也有ReentrantLock这样的可重入锁。
• 可重入锁的工作原理很简单，就是用一个计数器来记录锁被获取的次数，获取锁一次计数器+1，释放锁一次计数器-1，当计数器为0时，表示锁可用。