ReentrantLock分析测试

ReentrantLock 可重入锁，意思是同一个线程可以多次获取同一把锁，同样的再解锁时，也要 循环全部解锁
默认为公平锁，根据构造方法传参可以指定使用哪种锁， true 构建公平锁 FairSync类 ；false 非公平锁 NonfairSync类
公平锁：按照拿锁的先后顺序，一次加入队尾，当锁释放时，队头线程将去拿锁
非公平锁 ：竞争性拿锁，没有先来后到原则。
如锁释放时，等待队列中的线程尝试获取锁时，此时另外一个线程也来拿锁，就可能被抢先获取，线程过多时，会造成部分线程永远拿不到锁。
实测：

package com.aden.controller;

import lombok.SneakyThrows;
import org.junit.jupiter.api.Test;
import java.text.ParseException;
import java.util.List;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * @author sunzy
 * @version 1.0
 * @date 2020/9/21 13:53
 * @Description
 */
public class Test {
//测试公平锁
    static Lock lock = new ReentrantLock(true);
    @Test
    public void reentranLockTest(){
        try {
            for(int i=0;i<100;i++){
                //循环创建多个线程并运行，i作为每个线程的标识
                new Thread(new ThreadDemo(i)).start();
            }
            //休眠10000ms起阻塞作用，防止结果还未打印，主程序就结束
            Thread.sleep(10000);
        }catch (Exception e){
            e.printStackTrace();
        }
    }
    //线程测试静态内部类
    static class ThreadDemo implements Runnable{
        Integer id;
        public ThreadDemo(Integer id){
            this.id=id;
        }
        @SneakyThrows
        @Override
        public void run() {
        //此处同一个线程循环2次拿锁，模拟ReentrantLock同一线程，可重复拿锁特性
            for(int i=0;i<2;i++){
                System.out.println("线程"+id+"拿锁");
                lock.lock();
                System.out.println("线程"+id+"拿到锁");
            }
                for(int i=0;i<2;i++){
                    lock.unlock();
                    System.out.println("线程"+id+"：解锁");
            }
        }
    }
}

测试结果

再测试看下非公平锁，只需修改构造方法为false即可

非公平锁测试结果：