Java线程并发工具类CountDownLatch原理及用法

public class TestCountDownLatch {
  //CountDownLatch 为唯一的、共享的资源
  static CountDownLatch countDownLatch = new CountDownLatch(5);

  static class LatchDemo extends Thread{
    @Override
    public void run() {
      int sum = 0;
      for (int i = 0; i < 1000000; i++) {
        sum++;
      }
      System.out.println(getName()+"计算结果："+sum);
      countDownLatch.countDown();
    }
  }
  public static void main(String[] args) throws InterruptedException {

    long begin = System.currentTimeMillis();
    System.out.println("开始了-----"+begin);
    for (int i = 0; i < 5; i++) {
      new LatchDemo().start();
    }
    countDownLatch.await();

    long end = System.currentTimeMillis();
    System.out.println("结束了-----"+end);
    System.out.println("总共用时："+(end-begin));
  }
}

/**
开始了-----1571144894551
Thread-3计算结果：1000000
Thread-0计算结果：1000000
Thread-1计算结果：1000000
Thread-2计算结果：1000000
Thread-4计算结果：1000000
结束了-----1571144894559
总共用时：8
*/

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;
}

public class CyclicBarrierTest {
  // 自定义工作线程
  private static class Worker extends Thread {
    private CyclicBarrier cyclicBarrier;
    
    public Worker(CyclicBarrier cyclicBarrier) {
      this.cyclicBarrier = cyclicBarrier;
    }
    
    @Override
    public void run() {
      super.run();
      
      try {
        System.out.println(Thread.currentThread().getName() + "开始等待其他线程");
        cyclicBarrier.await();
        System.out.println(Thread.currentThread().getName() + "开始执行");
        // 工作线程开始处理，这里用Thread.sleep()来模拟业务处理
        Thread.sleep(1000);
        System.out.println(Thread.currentThread().getName() + "执行完毕");
      } catch (Exception e) {
        e.printStackTrace();
      }
    }
  }
 
  public static void main(String[] args) {
    int threadCount = 3;
    CyclicBarrier cyclicBarrier = new CyclicBarrier(threadCount);
    
    for (int i = 0; i < threadCount; i++) {
      System.out.println("创建工作线程" + i);
      Worker worker = new Worker(cyclicBarrier);
      worker.start();
    }
  }
}
/**
创建工作线程0
创建工作线程1
Thread-0开始等待其他线程
创建工作线程2
Thread-1开始等待其他线程
Thread-2开始等待其他线程
Thread-2开始执行
Thread-0开始执行
Thread-1开始执行
Thread-1执行完毕
Thread-0执行完毕
Thread-2执行完毕
*/

public class TestSemaphore {
  //初始化为1，互斥信号量
  private final static Semaphore mutex = new Semaphore(1);

  static class thread extends Thread{
    @Override
    public void run() {
      try {
        mutex.acquire();
        System.out.println(getName()+"开始工作");
      } catch (InterruptedException e) {
        e.printStackTrace();
      }finally {
        //使用完成释放锁
        mutex.release();
        System.out.println("锁释放!!!");
      }
    }
  }
  public static void main(String[] args) {
    for (int i = 0; i < 10; i++) {
      new Thread(new thread(),String.valueOf(i)).start();
    }
  }
}