并发同步列子

import java.util.concurrent.CountDownLatch;

public class CountDownLatchTest {
	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();
		}
	}
}

import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;

public class CyclicBarrierTest {
	// 一个同步辅助类，它允许一组线程互相等待，直到到达某个公共屏障点 (common barrier point)
	final CyclicBarrier barrier;

	// 线程数
	int count;

	class Worker implements Runnable {
		int index;

		Worker(int index) {
			this.index = index;
		}

		public void run() {
			System.out.println("第" + index + "个线程休眠" + (2 * index) + "秒！");
			try {
				Thread.sleep(2000 * index);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			System.out.println("第" + index + "个线程结束休眠！");

			try {
				// 等待其它线程都处理完毕后，再继续以下代码的执行
				barrier.await();
			} catch (InterruptedException e) {
				e.printStackTrace();
			} catch (BrokenBarrierException e) {
				e.printStackTrace();
			}

			System.out.println("=========" + index);
		}
	}

	public CyclicBarrierTest(int count) {
		this.count = count;

		// 公共屏障点 等待到5个线程后，执行相应的barrierAction
		barrier = new CyclicBarrier(count, new Runnable() {
			public void run() {
				System.out.println("全部线程已执行完毕！");
			}
		});

		for (int i = 1; i <= this.count; i++) {
			new Thread(new Worker(i)).start();
		}
	}

	public static void main(String[] args) {
		new CyclicBarrierTest(5);
	}
}

import java.util.concurrent.Semaphore;

public class SemaphoreTest {
    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();
            }
        }
    }
}