public CountDownLatch(int count) {  };  //參數count為計數值

public void await() throws InterruptedException { };   //調用await()方法的線程會被掛起，它會等待直到count值為0才繼續執行
public boolean await(long timeout, TimeUnit unit) throws InterruptedException { };  //和await()類似，只不過等待一定的時間后count值還沒變為0的話就會繼續執行
public void countDown() { };  //將count值減1

public class Test {
	 public static void main(String[] args) {    
		 final CountDownLatch latch = new CountDownLatch(2);
		 
		 new Thread(){
			 public void run() {
				 try {
					 System.out.println("子線程"+Thread.currentThread().getName()+"正在執行");
					Thread.sleep(3000);
					System.out.println("子線程"+Thread.currentThread().getName()+"執行完畢");
					latch.countDown();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			 };
		 }.start();
		 
		 new Thread(){
			 public void run() {
				 try {
					 System.out.println("子線程"+Thread.currentThread().getName()+"正在執行");
					 Thread.sleep(3000);
					 System.out.println("子線程"+Thread.currentThread().getName()+"執行完畢");
					 latch.countDown();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			 };
		 }.start();
		 
		 try {
			 System.out.println("等待2個子線程執行完畢...");
			latch.await();
			System.out.println("2個子線程已經執行完畢");
			System.out.println("繼續執行主線程");
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	 } 
}

public CyclicBarrier(int parties, Runnable barrierAction) {
}

public CyclicBarrier(int parties) {
}

public int await() throws InterruptedException, BrokenBarrierException { };
public int await(long timeout, TimeUnit unit)throws InterruptedException,BrokenBarrierException,TimeoutException { };

public class Test {
	public static void main(String[] args) {
		int N = 4;
		CyclicBarrier barrier  = new CyclicBarrier(N);
		for(int i=0;i<N;i++)
			new Writer(barrier).start();
	} 
	static class Writer extends Thread{
		private CyclicBarrier cyclicBarrier;
		public Writer(CyclicBarrier cyclicBarrier) {
			this.cyclicBarrier = cyclicBarrier;
		}

		@Override
		public void run() {
			System.out.println("線程"+Thread.currentThread().getName()+"正在寫入數據...");
			try {
				Thread.sleep(5000);      //以睡眠來模擬寫入數據操作
				System.out.println("線程"+Thread.currentThread().getName()+"寫入數據完畢，等待其他線程寫入完畢");
				cyclicBarrier.await();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}catch(BrokenBarrierException e){
				e.printStackTrace();
			}
			System.out.println("所有線程寫入完畢，繼續處理其他任務...");
		}
	}
}

public class Test {
	public static void main(String[] args) {
		int N = 4;
		CyclicBarrier barrier  = new CyclicBarrier(N,new Runnable() {
			@Override
			public void run() {
				System.out.println("當前線程"+Thread.currentThread().getName());	
			}
		});
		
		for(int i=0;i<N;i++)
			new Writer(barrier).start();
	} 
	static class Writer extends Thread{
		private CyclicBarrier cyclicBarrier;
		public Writer(CyclicBarrier cyclicBarrier) {
			this.cyclicBarrier = cyclicBarrier;
		}

		@Override
		public void run() {
			System.out.println("線程"+Thread.currentThread().getName()+"正在寫入數據...");
			try {
				Thread.sleep(5000);      //以睡眠來模擬寫入數據操作
				System.out.println("線程"+Thread.currentThread().getName()+"寫入數據完畢，等待其他線程寫入完畢");
				cyclicBarrier.await();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}catch(BrokenBarrierException e){
				e.printStackTrace();
			}
			System.out.println("所有線程寫入完畢，繼續處理其他任務...");
		}
	}
}

public class Test {
	public static void main(String[] args) {
		int N = 4;
		CyclicBarrier barrier  = new CyclicBarrier(N);
		
		for(int i=0;i<N;i++) {
			if(i<N-1)
				new Writer(barrier).start();
			else {
				try {
					Thread.sleep(5000);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				new Writer(barrier).start();
			}
		}
	} 
	static class Writer extends Thread{
		private CyclicBarrier cyclicBarrier;
		public Writer(CyclicBarrier cyclicBarrier) {
			this.cyclicBarrier = cyclicBarrier;
		}

		@Override
		public void run() {
			System.out.println("線程"+Thread.currentThread().getName()+"正在寫入數據...");
			try {
				Thread.sleep(5000);      //以睡眠來模擬寫入數據操作
				System.out.println("線程"+Thread.currentThread().getName()+"寫入數據完畢，等待其他線程寫入完畢");
				try {
					cyclicBarrier.await(2000, TimeUnit.MILLISECONDS);
				} catch (TimeoutException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			} catch (InterruptedException e) {
				e.printStackTrace();
			}catch(BrokenBarrierException e){
				e.printStackTrace();
			}
			System.out.println(Thread.currentThread().getName()+"所有線程寫入完畢，繼續處理其他任務...");
		}
	}
}

public class Test {
	public static void main(String[] args) {
		int N = 4;
		CyclicBarrier barrier  = new CyclicBarrier(N);
		
		for(int i=0;i<N;i++) {
			new Writer(barrier).start();
		}
		
		try {
			Thread.sleep(25000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		
		System.out.println("CyclicBarrier重用");
		
		for(int i=0;i<N;i++) {
			new Writer(barrier).start();
		}
	} 
	static class Writer extends Thread{
		private CyclicBarrier cyclicBarrier;
		public Writer(CyclicBarrier cyclicBarrier) {
			this.cyclicBarrier = cyclicBarrier;
		}

		@Override
		public void run() {
			System.out.println("線程"+Thread.currentThread().getName()+"正在寫入數據...");
			try {
				Thread.sleep(5000);      //以睡眠來模擬寫入數據操作
				System.out.println("線程"+Thread.currentThread().getName()+"寫入數據完畢，等待其他線程寫入完畢");
			
				cyclicBarrier.await();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}catch(BrokenBarrierException e){
				e.printStackTrace();
			}
			System.out.println(Thread.currentThread().getName()+"所有線程寫入完畢，繼續處理其他任務...");
		}
	}
}

public Semaphore(int permits) {          //參數permits表示許可數目，即同時可以允許多少線程進行訪問
    sync = new NonfairSync(permits);
}
public Semaphore(int permits, boolean fair) {    //這個多了一個參數fair表示是否是公平的，即等待時間越久的越先獲取許可
    sync = (fair)? new FairSync(permits) : new NonfairSync(permits);
}

public void acquire() throws InterruptedException {  }     //獲取一個許可
public void acquire(int permits) throws InterruptedException { }    //獲取permits個許可
public void release() { }          //釋放一個許可
public void release(int permits) { }    //釋放permits個許可

public boolean tryAcquire() { };    //嘗試獲取一個許可，若獲取成功，則立即返回true，若獲取失敗，則立即返回false
public boolean tryAcquire(long timeout, TimeUnit unit) throws InterruptedException { };  //嘗試獲取一個許可，若在指定的時間內獲取成功，則立即返回true，否則則立即返回false
public boolean tryAcquire(int permits) { }; //嘗試獲取permits個許可，若獲取成功，則立即返回true，若獲取失敗，則立即返回false
public boolean tryAcquire(int permits, long timeout, TimeUnit unit)	throws InterruptedException { }; //嘗試獲取permits個許可，若在指定的時間內獲取成功，則立即返回true，否則則立即返回false

public class Test {
	public static void main(String[] args) {
		int N = 8;            //工人數
		Semaphore semaphore = new Semaphore(5); //機器數目
		for(int i=0;i<N;i++)
			new Worker(i,semaphore).start();
	} 
	
	static class Worker extends Thread{
		private int num;
		private Semaphore semaphore;
		public Worker(int num,Semaphore semaphore){
			this.num = num;
			this.semaphore = semaphore;
		}
		
		@Override
		public void run() {
			try {
				semaphore.acquire();
				System.out.println("工人"+this.num+"占用一個機器在生產...");
				Thread.sleep(2000);
				System.out.println("工人"+this.num+"釋放出機器");
				semaphore.release();			
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
}