Java锁

1.公平锁&非公平锁

概念：所谓公平锁，就是多个线程按照申请锁的顺序来获取锁，类似排队，先到先得。而非公平锁，则是多个线程抢夺锁，会导致优先级反转或饥饿现象。

区别：

1. 公平锁在获取锁时先查看此锁维护的等待队列，为空或者当前线程是等待队列的队首，则直接占有锁，否则插入等待队列，以后会按照FIFO的规则从队列中取到自己。

java.util.concurrent.locks.ReentrantLock$FairSync.java
//公平锁
protected final boolean tryAcquire( int acquires) {
   
     final Thread current = Thread.currentThread();
     int c = getState();
     //状态为0，说明当前没有线程占有锁
     if (c ==  0 ) {
   
        //如果当前线程是等待队列的第一个或者等待队列为空，则通过cas指令设置state为1，当前线程获得锁
         if (isFirst(current) &&
             compareAndSetState( 0 , acquires)) {
   
             setExclusiveOwnerThread(current);
             return true ;
         }
     }
//如果当前线程本身就持有锁，那么叠加状态值，持续获得锁
     else if (current == getExclusiveOwnerThread()) {
   
         int nextc = c + acquires;
         if (nextc <  0 )
             throw new Error( "Maximum lock count exceeded" );
         setState(nextc);
         return true ;
      }
      //以上条件都不满足，那么线程进入等待队列。
      return false ;
}

2. 非公平锁比较粗鲁，上来直接先尝试占有锁，失败则采用公平方式。非公平的优点是吞吐量比公平锁更大。

java.util.concurrent.locks.ReentrantLock$Sync.java
//非公平锁
 final boolean nonfairTryAcquire(int acquires) {
   
            final Thread current = Thread.currentThread();
            int c = getState();
            if (c == 0) {
   
                //如果当前没有线程占有锁，当前线程直接通过cas指令占有锁，管他等待队列，就算自己排在队尾也是这样
                if (compareAndSetState(0, acquires)) {
   
                    setExclusiveOwnerThread(current);
                    return true;
                }
            }
             else if (current == getExclusiveOwnerThread()) {
   
                int nextc = c + acquires;
                if (nextc < 0) // overflow
                    throw new Error("Maximum lock count exceeded");
                setState(nextc);
                return true;
            }
            return false;
        }

synchronized和juc.ReentrantLock默认都是非公平锁。ReentrantLock在构造的时候传入true则是公平锁。

---

2.可重入锁/递归锁

可重入锁又叫递归锁，指的同一个线程在外层方法获得锁时，进入内层方法会自动获取锁。也就是说线程可以进入任何一个它已经拥有锁的代码块。比如get方法里面有set方法，两个方法都有同一把锁，得到了get的锁，就自动得到了set的锁。

举个例子：就像有了家门的锁、你进了家里面大门之后，家里面的厕所、书房、厨房就为你敞开。

可重入锁可以避免死锁问题：

package thread;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class ReentrantLockDemo {
   
    public static void main(String[] args) {
   
        Phone phone=new Phone();
        syncTest(phone);
        System.out.println();

        Thread t3=new Thread(phone);
        Thread t4=new Thread(phone);
        t3.start();
        t4.start();

    }

    private static void syncTest(Phone phone) {
   

        new Thread(()->{
   
            try{
   
                phone.sendSMS();
            }catch (Exception e){
   
                e.printStackTrace();
            }
        },"t1").start();

        new Thread(