摘要：將屏障重置為其初始狀態(tài)。注意，在由于其他原因造成損壞之后，實行重置可能會變得很復雜此時需要使用其他方式重新同步線程，并選擇其中一個線程來執(zhí)行重置。

1.線程限制 : 一個被線程限制的對象，由線程獨占，并且只能被占有它的線程修改
2.共享只讀 : 一個共享只讀的對象，在沒有額外同步的情況下，可以被多個線程并發(fā)訪問，
但是任何線程都不能修改它
3.線程安全對象 : 一個線程安全的對象或則容器，在內部通過同步機制來保證線程安全，
所以其他線程無需額外的同步就可以通過公共接口隨意訪問它
4.被守護對象 : 被守護對象只能通過獲取特定的鎖來訪問

采用synchronized關鍵字同步，缺點 ：

不能完成做到線程安全

性能差

ArrayLisy -> Vector, Stack
HashMap -> HashTable (key、value不能為null)
Collections.synchronizedXXX(List、Set、Map)

ArrayList -> CopyOnWriteArrayList
HashSet、TreeSet -> CopyOnWriteArraySet ConcurrentSkipListSet
HashMap、TreeMap -> ConcurrentHashMap ConcurrentSkipListMap

AbstractQueuedSynchronizer - AQS

使用Node實現(xiàn)FIFO隊列，可以用于構建鎖或則其他同步裝置的基礎框架

利用一個int類型表示狀態(tài)

使用方法是基礎

子類通過繼承并通過實現(xiàn)它的方法管理其狀態(tài) { acquire 和 release} 的方法操縱狀態(tài)

可以同時實現(xiàn)排他鎖和共享鎖模式（獨占、共享）

CountDownLatch
Semaphore
CyclicBarrier
ReentrantLock
Condition
FutureTask

CountDownLatch是一個同步工具類，它允許一個或多個線程一直等待，直到其他線程執(zhí)行完后再執(zhí)行。例如，應用程序的主線程希望在負責啟動框架服務的線程已經(jīng)啟動所有框架服務之后執(zhí)行。

CountDownLatch是通過一個計數(shù)器來實現(xiàn)的，計數(shù)器的初始化值為線程的數(shù)量。每當一個線程完成了自己的任務后，計數(shù)器的值就相應得減1。當計數(shù)器到達0時，表示所有的線程都已完成任務，然后在閉鎖上等待的線程就可以恢復執(zhí)行任務。

@Self4j
public class CountDownLatchExample {

    private final  static int threadCount = 200;
    
    public static void main(String[] arg) {
    
        ExecutorService exec = Executors.newCachedThreadPool(); 
        
        final CountDownLatch lacth = new CountDownLatch(5);
        
        for (int i = 0; i < 1000; i++) {
            exec.excute( () -> {
            final int threadNum  = i;
            try {
                test(threadNum);
            } catch (Exception e) {
                log.error("exception", e);
            } finally {
                // latch遞減
                lacth.countDown();
            }
            });
        }
        // 等待latch計數(shù)器為0，則繼續(xù)往下執(zhí)行
        latch.await();
        // latch的await方法也可以傳入等待時間，等到等待時間后不管有沒完成計數(shù)都往下執(zhí)行
        // latch.await( 10, TimeUnit.MILLISECONDS);
        log.info("finished");
        exec.shutdown();
    }

    public static void test(int i)  throw Exception{
        log.info("thread: {}", i);
    }
}

Semaphore(int permits):構造方法，創(chuàng)建具有給定許可數(shù)的計數(shù)信號量并設置為非公平信號量。
Semaphore(int permits,boolean fair):構造方法，當fair等于true時，創(chuàng)建具有給定許可數(shù)的計數(shù)信號量并設置為公平信號量。
void acquire():從此信號量獲取一個許可前線程將一直阻塞。
void acquire(int n):從此信號量獲取給定數(shù)目許可，在提供這些許可前一直將線程阻塞。
void release():釋放一個許可，將其返回給信號量。就如同車開走返回一個車位。
void release(int n):釋放n個許可。
int availablePermits()：獲取當前可用的許可數(shù)。
boolean tryAcquire()：僅在調用時此信號量存在一個可用許可，才從信號量獲取許可。
boolean tryAcquire(int permits)：僅在調用時此信號量中有給定數(shù)目的許可時，才從此信號量中獲取這些許可。

boolean tryAcquire(int permits,
                          long timeout,
                          TimeUnit unit)
                   throws InterruptedException

如果在給定的等待時間內此信號量有可用的所有許可，并且當前線程未被 中斷，則從此信號量獲取給定數(shù)目的許可。

@Self4j
public class SemaphoreExample {

    private final  static int threadCount = 200;

    public static void main(String[] arg) {

        ExecutorService exec = Executors.newCachedThreadPool(); 
    
        final Semaphore semaphore = new Semaphore(3);
    
        for (int i = 0; i < threadCount; i++) {
            exec.excute( () ）-> {
            final int threadNum  = i;
            try {
                // tryAcquire會嘗試去獲取一個信號量，如果獲取不到
                // 則什么都不會發(fā)生，走接下來的邏輯
                // if (semaphore.tryAcquire(1)) {
                //    test(i);
                //    semaphore.release();//釋放一個信號量
                // }
                semaphore.acquire();//獲取一個信號量
                test(i);
                semaphore.release();//釋放一個信號量
            } catch (Exception e) {
                log.error("exception", e);
            } 
            });
        }
        log.info("finished");
        exec.shutdown();
    }

    public static void test(int i)  throw Exception{
        log.info("thread: {}", i);
    }
}

一個同步輔助類，它允許一組線程互相等待，直到到達某個公共屏障點 (common barrier point)。

CyclicBarrier(int parties, Runnable barrierAction)
創(chuàng)建一個新的 CyclicBarrier，它將在給定數(shù)量的參與者（線程）處于等待狀態(tài)時啟動，并在啟動 barrier 時執(zhí)行給定的屏障操作，該操作由最后一個進入 barrier 的線程執(zhí)行。

CyclicBarrier(int parties)
創(chuàng)建一個新的 CyclicBarrier，它將在給定數(shù)量的參與者（線程）處于等待狀態(tài)時啟動，但它不會在啟動 barrier 時執(zhí)行預定義的操作。

int await()
在所有 參與者都已經(jīng)在此 barrier 上調用 await 方法之前，將一直等待。

int await(long timeout,
                 TimeUnit unit)
          throws InterruptedException,
                 BrokenBarrierException,
                 TimeoutException

在所有 參與者都已經(jīng)在此屏障上調用 await 方法之前將一直等待,或者超出了指定的等待時間。

boolean isBroken() ： 查詢此屏障是否處于損壞狀態(tài)。

void reset() ：
將屏障重置為其初始狀態(tài)。如果所有參與者目前都在屏障處等待，則它們將返回，同時拋出一個 BrokenBarrierException。注意，在由于其他原因造成損壞 之后，實行重置可能會變得很復雜；此時需要使用其他方式重新同步線程，并選擇其中一個線程來執(zhí)行重置。與為后續(xù)使用創(chuàng)建一個新 barrier 相比，這種方法可能更好一些。

int getNumberWaiting() ：返回當前在屏障處等待的參與者數(shù)目。此方法主要用于調試和斷言。

@Self4j
public class CyclicBarrierExample {

    private final  static int threadCount = 200;
    
    private final static CyclicBarrier cyclicBarrier = new CyclicBarrier(7, 
        () -> {
        log.info("callback is running !");
        }
    );
    
    public static void main(String[] arg) {
    
        ExecutorService exec = Executors.newCachedThreadPool(); 
        
        for (int i = 0; i < threadCount; i++) {
            exec.excute( () -> {
                final int threadNum  = i;
                try {
                    race(i);
                } catch (Exception e) {
                    log.error("exception", e);
                } 
            });
        }
        log.info("finished");
        
        exec.shutdown();
    }
    
    public static void race(int i)  throw Exception{
        log.info("thread {} is ready", i);
        cyclicBarrier.await();
        log.info("thread {} is continue", i);
    }
}