`ReentrantLock`中公平锁的**lock方法**```javastatic final class FairSync extends Sync {   final void lock() {     acquire(1);   }  // AbstractQueuedSynchronizer.acquire(int arg)   public final void acquire(int arg) {     if (!tryAcquire(arg) &&       acquireQueued(addWaiter(Node.EXCLUSIVE), arg))       selfInterrupt();   }  protected final boolean tryAcquire(int acquires) {     final Thread current = Thread.currentThread();     int c = getState();     if (c == 0) {      // 1. 和非公平锁相比，这里多了一个判断：是否有线程在等待       if (!hasQueuedPredecessors() &&         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;   } }

static final class NonfairSync extends Sync {   final void lock() {     // 2. 和公平锁相比，这里会直接先进行一次CAS，成功就返回了     if (compareAndSetState(0, 1))       setExclusiveOwnerThread(Thread.currentThread());       else        acquire(1); }// AbstractQueuedSynchronizer.acquire(int arg) public final void acquire(int arg) {   if (!tryAcquire(arg) &&     acquireQueued(addWaiter(Node.EXCLUSIVE), arg))     selfInterrupt(); }protected final boolean tryAcquire(int acquires) {   return nonfairTryAcquire(acquires);   } }/** 1. Performs non-fair tryLock. tryAcquire is implemented in  2. subclasses, but both need nonfair try for trylock method. */ final boolean nonfairTryAcquire(int acquires) {   final Thread current = Thread.currentThread();   int c = getState();   if (c == 0) {     // 这里没有对阻塞队列进行判断     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; }

isHeldExclusively()//该线程是否正在独占资源。只有用到condition才需要去实现它。 tryAcquire(int)//独占方式。尝试获取资源，成功则返回true，失败则返回false。 tryRelease(int)//独占方式。尝试释放资源，成功则返回true，失败则返回false。 tryAcquireShared(int)//共享方式。尝试获取资源。负数表示失败；0表示成功，但没有剩余可用资源； 正数表示成功，且有剩余资源。 tryReleaseShared(int)//共享方式。尝试释放资源，成功则返回true，失败则返回false。

/*** @author Snailclimb * @date 2018年9月30日 * @Description: 需要一次性拿一个许可的情况 */public class SemaphoreExample1 {   // 请求的数量   private static final int threadCount = 550;   public static void main(String[] args) throws InterruptedException {     // 创建一个具有固定线程数量的线程池对象（如果这里线程池的线程数量给太少的话你会发现执行的很 慢）     ExecutorService threadPool = Executors.newFixedThreadPool(300);     // 一次只能允许执行的线程数量。     final Semaphore semaphore = new Semaphore(20);         for (int i = 0; i < threadCount; i++) {       final int threadnum = i;       threadPool.execute(() -> {// Lambda 表达式的运用         try {           semaphore.acquire();// 获取一个许可，所以可运行线程数量为20/1=20        test(threadnum);         semaphore.release();// 释放一个许可       } catch (InterruptedException e) {         // TODO Auto-generated catch block         e.printStackTrace();       }           });   }  threadPool.shutdown();   System.out.println("finish"); }  public static void test(int threadnum) throws InterruptedException {     Thread.sleep(1000);// 模拟请求的耗时操作     System.out.println("threadnum:" + threadnum);     Thread.sleep(1000);// 模拟请求的耗时操作   } }

semaphore.acquire(5);// 获取5个许可，所以可运行线程数量为20/5=4 test(threadnum); semaphore.release(5);// 获取5个许可，所以可运行线程数量为20/5=4

public Semaphore(int permits) {   sync = new NonfairSync(permits); }public Semaphore(int permits, boolean fair) {   sync = fair ? new FairSync(permits) : new NonfairSync(permits); }

/*** @author SnailClimb * @date 2020年12月10日 * @Description: CountDownLatch 使用方法示例 */
public class CountDownLatchExample1 {   // 请求的数量   private static final int threadCount = 550;     public static void main(String[] args) throws InterruptedException {     // 创建一个具有固定线程数量的线程池对象（如果这里线程池的线程数量给太少的话你会发现执行的很 慢）     ExecutorService threadPool = Executors.newFixedThreadPool(300);     final CountDownLatch countDownLatch = new CountDownLatch(threadCount);     for (int i = 0; i < threadCount; i++) {       final int threadnum = i;       threadPool.execute(() -> {// Lambda 表达式的运用         try {           test(threadnum);         } catch (InterruptedException e) {           // TODO Auto-generated catch block           e.printStackTrace();         } finally {           countDownLatch.countDown();// 表示一个请求已经被完成           }      });     }    countDownLatch.await();     threadPool.shutdown();     System.out.println("finish");   }    public static void test(int threadnum) throws InterruptedException {     Thread.sleep(1000);// 模拟请求的耗时操作     System.out.println("threadnum:" + threadnum);     Thread.sleep(1000);// 模拟请求的耗时操作   } }

for (int i = 0; i < threadCount-1; i++) {   ....... }

public CyclicBarrier(int parties) {   this(parties, null); }public CyclicBarrier(int parties, Runnable barrierAction) {   if (parties <= 0) throw new IllegalArgumentException();   this.parties = parties;   this.count = parties;   this.barrierCommand = barrierAction; }

/** * * @author Snailclimb  * @date 2018年10月1日  * @Description: 测试 CyclicBarrier 类中带参数的 await() 方法 */public class CyclicBarrierExample2 {   // 请求的数量   private static final int threadCount = 550;   // 需要同步的线程数量   private static final CyclicBarrier cyclicBarrier = new CyclicBarrier(5);   public static void main(String[] args) throws InterruptedException {     // 创建线程池     ExecutorService threadPool = Executors.newFixedThreadPool(10);           for (int i = 0; i < threadCount; i++) {        final int threadNum = i; Thread.sleep(1000);        threadPool.execute(() -> {          try {            test(threadNum);          } catch (InterruptedException e) {          // TODO Auto-generated catch block         e.printStackTrace();        } catch (BrokenBarrierException e) {          // TODO Auto-generated catch block          e.printStackTrace();        }      });     }    threadPool.shutdown();   }  public static void test(int threadnum) throws InterruptedException, BrokenBarrierException {     System.out.println("threadnum:" + threadnum + "is ready");     try {     /**等待60秒，保证子线程完全执行结束*/     cyclicBarrier.await(60, TimeUnit.SECONDS);   } catch (Exception e) {     System.out.println("-----CyclicBarrierException------");   }  System.out.println("threadnum:" + threadnum + "is finish");   }   }

threadnum:0is ready threadnum:1is ready threadnum:2is ready threadnum:3is ready threadnum:4is ready threadnum:4is finish threadnum:0is finish threadnum:1is finish threadnum:2is finish threadnum:3is finish threadnum:5is ready threadnum:6is ready threadnum:7is ready threadnum:8is ready threadnum:9is ready 

### 最后
作为过来人，小编是整理了很多进阶架构视频资料、面试文档以及PDF的学习资料，针对上面一套系统大纲小编也有对应的相关进阶架构视频资料，如果**‘你’**确定好自己未来的道路或者想学习提升自己技术栈、技术知识的小伙伴们**可以[点击这里来获取免费学习资料](https://gitee.com/vip204888/java-p7)提升自己（全套面试文档、PDF、进阶架构视频）**
![](https://static001.geekbang.org/infoq/9d/9d445804a84a42d3180b5e82c93438fb.png)![](https://static001.geekbang.org/infoq/a1/a1b4892675f0f70812079a83326561bd.png)

#