Java JDK 线程池学习记录

1. newSingleThreadExecutor

单线程线程池,会将放进线程池的线程，单线程执行

ExecutorService executorService = Executors.newSingleThreadExecutor();

1. execuorService.execute(Runnable Command)
   执行一个线程没有返回值
2. execuorService.submit()
   执行一个线程，有返回值用future接收，使用future.get()会阻塞线程

Future<String> s = executorService.submite(new Thread());
System.out.println(s.get());

3. executorService.invokeAny()
   执行一个线程集合，一旦出现一个返回值，就会结束其他线程，如果线程执行过快，会导致第二个线程已经执行，返回其中一个线程的返回结果
4. executorService.invokeAll()
   执行一个线程集合，执行所有线程，返回所有线程的返回结果
5. executorService.shutdown()
   执行完所有线程后关闭线程池
6. executorService.shutdownNow()
   立刻关闭线程池
7. executorService.isShutdown()
   判断线程池是否关闭
8. executorService.awaitTermination()
   设置线程池超时时间，判断超过时间后，是否关闭线程池

2. newFixedThreadPool

创建一个长线程池，控制最大并发数，超出线程池数量，则会等待

3. newCachedThreadPool

创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程

4. newScheduledThreadPool

创建一个可定期或者延时执行任务的定长线程池，支持定时及周期性任务执行

ScheduledExecutorService executorService = Executors.newScheduledThreadPool(10);
//延迟一定时间执行
public <V> ScheduledFuture<V> schedule(Callable<V> callable,
                                           long delay, TimeUnit unit);
//延迟一定时间，周期执行
public ScheduledFuture<?> scheduleWithFixedDelay(Runnable command,
                                                     long initialDelay,
                                                     long delay,
                                                     TimeUnit unit);
//延迟一定时间，按照一定比例执行定时任务
public ScheduledFuture<?> scheduleAtFixedRate(Runnable command,
                                                  long initialDelay,
                                                  long period,
                                                  TimeUnit unit);

5.CountDownLatch

初始化计数器数量

CountDownLatch latch = new CountDownLatch(3);

在线程中进行计数器减一

		@SneakyThrows
        @Override
        public void run() {
            latch.countDown();
            if(time%2==0){
                Thread.sleep(1000l);
            }else {
                Thread.sleep(1500l);
            }
            System.out.println(Thread.currentThread().getName() + " " + this.name);
        }

使用latch.await()的线程会等待latch计数器为0时执行