Java系统预定义线程池_预定义的线程池-CSDN博客

线程池作用就是限制系统中执行线程的数量
根据系统的环境情况，可以自动或手动设置线程数量，达到运行的最佳效果；少了浪费了系统资源，多了造成系统拥挤效率不高。用线程池控制线程数量，其他线程排队等候。一个任务执行完毕，再从队列的中取最前面的任务开始执行。若队列中没有等待进程，线程池的这一资源处于等待。当一个新任务需要运行时，如果线程池中有等待的工作线程，就可以开始运行了；否则进入等待队列。

为什么要用线程池：

减少了创建和销毁线程的次数，每个工作线程都可以被重复利用，可执行多个任务可以根据系统的承受能力，调整线程池中工作线线程的数目，防止因为因为消耗过多的内存，而把服务器累趴下(每个线程需要大约1MB内存，线程开的越多，消耗的内存也就越大，最后死机)

系统预定义的线程池：

1、可缓存线程池

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

 public static ExecutorService newCachedThreadPool() {
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE, 60L, TimeUnit.SECONDS,
                                      new SynchronousQueue<Runnable>());
 }

工作线程的创建数量几乎没有限制(其实也有限制的,数目为Interger.MAX_VALUE), 这样可灵活的往线程池中添加线程。
如果长时间没有往线程池中提交任务，即如果工作线程空闲了指定的时间(默认为1分钟)，则该工作线程将自动终止。终止后，如果你又提交了新的任务，则线程池重新创建一个工作线程。
在使用CachedThreadPool时，一定要注意控制任务的数量，否则，由于大量线程同时运行，很有会造成系统瘫痪。

ExecutorService pool=Executors.newCachedThreadPool();
for(int k=0;k<10;k++)
   pool.execute(()->{   向线程池中提交任务，任务是通过Runnable接口进行定义的
      for(int i=0;i<10;i++)
           System.out.println(Thread.currentThread()+":"+i);
   });
pool.shutdown();

特点：

重用之前的线程
适合执行许多短期异步任务的程序。
调用execute() 将重用以前构造的线程
如果没有可用的线程，则创建一个新线程并添加到池中
默认为60s未使用就被终止和移除
长期闲置的池将会不消耗任何资源

2、定长线程池

newFixedThreadPool 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。

public static ExecutorService newFixedThreadPool(int nThreads, ThreadFactory threadFactory) {
        return new ThreadPoolExecutor(nThreads, nThreads,
                                      0L, TimeUnit.MILLISECONDS,
                                      new LinkedBlockingQueue<Runnable>(),
                                      threadFactory);
    }

- newFixedThreadPool可控制线程最大并发数，当线程池中的线程数达到其设定大小时，其余新创建的线程会在LinkedBlockingQueue队列中等待
- 当线程池中的某个线程失败而终止时，新的线程会代替它执行剩下的任务
- 线程池中的线程只有在显式调用shutdown函数时才会退出线程池

ExecutorService newFixedThreadPool = Executors.newFixedThreadPool(3);
for (int i = 0; i < 10; ++i) {
    newFixedThreadPool.execute(new Runnable() {
        public void run() {
            System.out.println(Thread.currentThread().getName());
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    });
}

特点：

创建重用固定数量线程的线程池，不能随时新建线程
当所有线程都处于活动状态时，如果提交了其他任务，他们将在队列中等待一个线程可用
线程会一直存在，直到调用shutdown

3、周期定长线程池

newScheduledThreadPool创建一个定长线程池，支持定时及周期性任务执行。

ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(3);
DateFormat df=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
System.out.println(df.format(new Date()));
//定时
scheduledThreadPool.schedule(new Runnable() {
    public void run() {
        System.out.println("thread:" + Thread.currentThread().getName() + ",time:" + sdf1.format(new Date()));
        Thread.sleep(10);
    }
}, 3, TimeUnit.SECONDS);  3秒之后开始执行工作任务，除非自定義實現，否則只執行一次

實際調用的構造器為
public ScheduledThreadPoolExecutor(int corePoolSize) {
        super(corePoolSize核心綫程數, Integer.MAX_VALUE最大綫程數,
              DEFAULT_KEEPALIVE_MILLIS, MILLISECONDS,
              new DelayedWorkQueue());
    }
    

//循环周期执行
ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(3);
DateFormat df=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
System.out.println(df.format(new Date()));
scheduledThreadPool.scheduleAtFixedRate(()->{
    System.out.println(Thread.currentThread()+"-->"+df.format(new Date()));
    Thread.sleep(10);
    System.out.println("delay 1 seconds, and excute every 3 seconds");
}, 1, 3, TimeUnit.SECONDS); 延遲1秒后開始執行第一次，以後每隔3秒執行一次

特点：

设定延迟时间
定期执行，空闲线程会进行保留

4、单线程化线程池

newSingleThreadExecutor创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，
保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。

ExecutorService singleThreadPool = Executors.newSingleThreadExecutor();
for(int i = 0 ; i < 50 ; i++)
    singleThreadPool.submit(new TestThread((i + 1)));
singleThreadPool.shutdown();

class TestThread implements Runnable{
    private String name;
    public TestThread(String name){
        this.name=name;
    }
    public void run() {
        for(int i=0;i<10;i++){
            System.out.println(Thread.currentThread()+"-->"+name);
            Thread.yield();
        }
    }
}

特点：

在任何情况下都不会有超过一个任务处于活动状态
与newFixedThreadPool(1)不同是不能重新配置加入线程，使用FinalizableDelegatedExecutorService进行包装
能保证执行顺序，先提交的先执行
当线程执行中出现异常，去创建一个新的线程替换之

ExecutorService singleThreadPool = Executors.newFixedThreadPool(1);
ThreadPoolExecutor executor = (ThreadPoolExecutor) singleThreadPool;
executor.setCorePoolSize(4); 没问题，可以修改核心线程数
//但是如果Executors.newSingleThreadExecutor修改出错

5、周期单线程池

newSingleThreadScheduledExecutor创建一个单线程化的线程池，可以在指定延迟后指定线程任务。

6、工作窃取算法的线程池

newWorkStealingPool(int)/()创建持有足够数量线程的线程池来支持给定的并行级别，该方法还会使用多个队列来减少竞争，无参则是根据CPU个数定义并行级别。
工作窃取核心思想是，自己的活干完了去看看别人有没有没干完的活，如果有就拿过来帮他干。核心思想是work-stealing工作窃取，ForkJoinPool提供了一个更有效的利用线程的机制，当ThreadPoolExecutor还在用单个队列存放任务时，ForkJoinPool已经分配了与线程数相等的队列，当有任务加入线程池时，会被平均分配到对应的队列上，各线程进行正常工作，当有线程提前完成时，会从队列的末端窃取其他线程未执行完的任务，当任务量特别大时，CPU多的计算机会表现出更好的性能。
实现机制是：为每个工作线程分配一个双端队列(本地队列)用于存放需要执行的任务，当自己的队列没有数据的时候从其它工作者队列中获得一个任务继续执行。

CountDownLatch latch=new CountDownLatch(10);
ExecutorService es=Executors.newWorkStealingPool(2);
Random r=new Random();
for(int i=0;i<10;i++)
    es.submit(new MyRunnable(r.nextInt(10), latch));
latch.await();
System.out.println("....end....");

class MyRunnable implements Runnable{
    private int len;
    private CountDownLatch latch;
    public MyRunnable(int len,CountDownLatch latch){
        this.len=len;
        this.latch=latch;
    }
    public void run() {
        try{
            System.out.println(Thread.currentThread());
            try{
                Thread.sleep(200*len);
            } catch(InterruptedException e){
                e.printStackTrace();
            }
        } finally{
            latch.countDown();
        }
    }
}

另外Java 8为ForkJoinPool添加了一个通用线程池，这个线程池用来处理那些没有被显式提交到任何线程池的任务。它是ForkJoinPool类型上的一个静态元素，它拥有的默认线程数量等于运行计算机上的处理器数量。当调用Arrays类上添加的新方法时，自动并行化就会发生。比如用来排序一个数组的并行快速排序，用来对一个数组中的元素进行并行遍历。自动并行化也被运用在Java 8新添加的Stream API中parallelStream()方法