[Java] java并发包中CountDownLatch和线程池的使用详解

CountDownLatch countDownLatch = new CountDownLatch(count);

int ThreadNum = 16;
CountDownLatch countDownLatch = new CountDownLatch(ThreadNum);
for(int i = 0; i < ThreadNum ; i++){
 final int finalI = i;
 new Thread(() -> {
  int n = 0;
  System.out.println("线程应该做的事情");
  while(n < 10){
   n++;
  }
  countDownLatch.countDown();
 }).start();
}
try{
 countDownLatch.await();
}catch(InterruptedException e){
 logger.infor("InterruptedException!!");
}

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
public class ThreadPoolTest {
 public static void main(String[] args) {
  ThreadPoolExecutor pool = new ThreadPoolExecutor(10,20,60, 
  TimeUnit.SECOUNDS,new ArrayBlockingQueue<Runnable>(15000),new ThreadFactory(){
   private AtomicInteger threadId = new AtomicInteger(0);
   @Override
   public Thread newThread(Runnable r){
  Thread thread = new Thread(r);
  thread.setDaemon(true);
  String prefix = "thread-";
  thread.setName(prefix+threadId.incrementAndGet());
  return thread;
   } 
  });
 }
}

public class CountDownLatchTest {
 
 public static void main(String[] args) throws Exception {
  final CountDownLatch cdl = new CountDownLatch(2);
  new Thread(){
   public void run() {
  try {
   System.out.println("等待老爸回家...");
   Thread.sleep(5000);
   cdl.countDown();
  } catch (InterruptedException e) {
   e.printStackTrace();
  }
  
   };
  }.start();
  
  new Thread(){
   public void run() {
  try {
   System.out.println("等待老妈回家...");
   Thread.sleep(5000);
   cdl.countDown();
  } catch (InterruptedException e) {
   e.printStackTrace();
  }
   };
  }.start();
  
  cdl.await();
  System.out.println("老爸老妈回来了...");
  System.out.println("晚宴开始了...");
 }
 
}

public class CyclicBarrierTest {
 
 public static void main(String[] args) {
  int count = 3;
  CyclicBarrier cb = new CyclicBarrier(count, new Runnable() {
   @Override
   public void run() {
  //此处所有线程都调用了await方法之后，会走到这里
  System.out.println("所有线程操作完成之后都调用了await方法");
   }
  });
  
  for(int i=0;i<count;i++){
   new WriteLogHandler(cb).start();
  }
 }
 
 static class WriteLogHandler extends Thread{
  
  private CyclicBarrier cb = null;
  
  public WriteLogHandler(CyclicBarrier cb) {
   this.cb = cb;
  }
  
  @Override
  public void run() {
   try {
  System.out.println("线程：" + Thread.currentThread().getName() + "开始写日志");
  Thread.sleep(2000);
  System.out.println("线程：" + Thread.currentThread().getName() + "写日志结束，等待其他线程");
  cb.await();
  
  System.out.println("所有线程写日志数据结束，继续其他操作");
   } catch (Exception e) {
  e.printStackTrace();
   }
  }
 }
 
}

Semaphore类似锁的用法，用于控制对某资源的访问权限，示例代码如下：
public class SemaphoreTest {
 
 public static void main(String[] args) {
  ExecutorService executor = Executors.newCachedThreadPool();
  final Semaphore semaphore = new Semaphore(5);
  
  for(int i=0;i<10;i++){
   final int num = i;
   executor.execute(new Runnable() {
  @Override
  public void run() {
   try {
    semaphore.acquire();
    System.out.println("正在执行任务" + num);
    Thread.sleep((long)Math.random() * 1000);
    System.out.println("任务" + num + "执行结束");
    semaphore.release();
   } catch (Exception e) {
    e.printStackTrace();
   }
  }
   });
  }
  executor.shutdown();
 }
 
}