Fair lock and unfair lock

Fair lock : It means that multiple threads acquire locks according to the order in which they apply for locks , It's like waiting in line for a meal , first come , first served . 
Not fair lock : The order in which multiple threads acquire locks is not the order in which they apply for locks , It is possible that the thread that applies later acquires the lock prior to the thread that applies first ,  In the case of high concurrency , It may cause priority inversion or blocking .

Fair lock / Not fair lock
Under contract ReentrantLock The creation of can specify the constructor of boolean Type to get a fair lock or an unfair lock , Default is unfair lock  

 Look look=new ReentrantLock();

  //NonfairSync Just an unfair lock 
   public ReentrantLock() {
        sync = new NonfairSync();
    }
   //fair Create a fair lock for true , by false Create an unfair lock 
   public ReentrantLock(boolean fair) {
        sync = fair ? new FairSync() : new NonfairSync();
    }

On the difference between the two : 
Fair lock : Threads acquire a fair lock in the order in which they requested it  
Fair lock , It's just fair , In a concurrent environment , Each thread will first check the waiting queue maintained by the lock when acquiring the lock , If it is empty , Or the current thread is the first one in the waiting queue , Take possession of the lock , Otherwise it will join the waiting queue , In the future, I will follow FIFO The rules of get themselves from the queue .
Not fair lock : a nonfair lock permits barging: threads requesting a lock can jump ahead of the queue of waiting threads if the lockhappens to be available when it is requested.  
Not fair lock It's rude , Come up and try to own the lock , If the attempt fails , Just like fair lock . ( Grab the lock when you come up . If you can't get it, just queue up like a fair lock , First, first , If you can't get it, you'll get it first )  
Not fair lock The advantages of , Throughput is greater than fair lock

Reentrant lock ( Also called recursive locking ) 
It refers to the lock obtained by the outer function of the same thread ﹐ The inner recursive function can still get the code of the lock , When the same thread acquires the lock in the outer method , When entering the inner layer, the method will automatically acquire the lock .
That is said , A thread can enter any block of code in which it already has a lock .
ReentrantLock/synchronized It's a typical reentry lock  
The most important function of reentry lock is to avoid deadlock
lock() and unlock() As long as the pairing can work properly