【Java 多线程 2】线程池

一、线程池的优势

降低系统资源消耗，通过重用已存在的线程，降低线程创建和销毁造成的消耗；
提高系统响应速度，当有任务到达时，通过复用已存在的线程，无需等待新线程的创建便能立即执行；
方便线程并发数的管控。因为线程若是无限制的创建，可能会导致内存占用过多而产生OOM，并且会造成cpu过度切换（cpu切换线程是有时间成本的（需要保持当前执行线程的现场，并恢复要执行线程的现场））。
提供更强大的功能，延时定时线程池。

二、线程池主要方法

public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue) {
    this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
         Executors.defaultThreadFactory(), defaultHandler);
}

参数详解

corePoolSize（线程池基本大小）：当向线程池提交一个任务时，若线程池已创建的线程数小于corePoolSize，即便此时存在空闲线程，也会通过创建一个新线程来执行该任务，直到已创建的线程数大于或等于corePoolSize时，（除了利用提交新任务来创建和启动线程（按需构造），也可以通过 prestartCoreThread() 或 prestartAllCoreThreads() 方法来提前启动线程池中的基本线程。）
maximumPoolSize（线程池最大大小）：线程池所允许的最大线程个数。当队列满了，且已创建的线程数小于maximumPoolSize，则线程池会创建新的线程来执行任务。另外，对于无界队列，可忽略该参数。
keepAliveTime（线程存活保持时间）当线程池中线程数大于核心线程数时，线程的空闲时间如果超过线程存活时间，那么这个线程就会被销毁，直到线程池中的线程数小于等于核心线程数。
workQueue（任务队列）：用于传输和保存等待执行任务的阻塞队列。
threadFactory（线程工厂）：用于创建新线程。threadFactory创建的线程也是采用new Thread()方式，threadFactory创建的线程名都具有统一的风格：pool-m-thread-n（m为线程池的编号，n为线程池内的线程编号）。
handler（线程饱和策略）：当线程池和队列都满了，再加入线程会执行此策略。

三、线程池流程

1、判断核心线程池是否已满，没满则创建一个新的工作线程来执行任务。已满则执行饱和策略。
2、判断任务队列是否已满，没满则将新提交的任务添加在工作队列，已满则执行饱和策略。
3、判断整个线程池是否已满，没满则创建一个新的工作线程来执行任务，已满则执行饱和策略。

注意：

判断线程池中当前线程数是否大于核心线程数，如果小于，在创建一个新的线程来执行任务，则执行饱和策略。
判断任务队列是否已满，没满则将新提交的任务添加在工作队列，已满则执行饱和策略。
判断线程池中当前线程数是否大于最大线程数，如果小于，则创建一个新的线程来执行任务，如果大于，则执行饱和策略。

四、线程池为什么需要使用（阻塞）队列？

回到了非线程池缺点中的第3点：

因为线程若是无限制的创建，可能会导致内存占用过多而产生OOM，并且会造成cpu过度切换。
另外回到了非线程池缺点中的第1点：
创建线程池的消耗较高。
或者下面这个网上并不高明的回答：
线程池创建线程需要获取mainlock这个全局锁，影响并发效率，阻塞队列可以很好的缓冲。

五、线程池为什么要使用阻塞队列而不使用非阻塞队列？

阻塞队列可以保证任务队列中没有任务时阻塞获取任务的线程，使得线程进入wait状态，释放cpu资源。
当队列中有任务时才唤醒对应线程从队列中取出消息进行执行。
使得在线程不至于一直占用cpu资源。

（线程执行完任务后通过循环再次从任务队列中取出任务进行执行，代码片段如下
while (task != null || (task = getTask()) != null) {}）。

不用阻塞队列也是可以的，不过实现起来比较麻烦而已，有好用的为啥不用呢？

六、java中提供的线程池

Executors类提供了4种不同的线程池：newCachedThreadPool, newFixedThreadPool, newScheduledThreadPool, newSingleThreadExecutor。

newCachedThreadPool：用来创建一个可以无限扩大的线程池，适用于负载较轻的场景，执行短期异步任务。（可以使得任务快速得到执行，因为任务时间执行短，可以很快结束，也不会造成cpu过度切换）
newFixedThreadPool：创建一个固定大小的线程池，因为采用无界的阻塞队列，所以实际线程数量永远不会变化，适用于负载较重的场景，对当前线程数量进行限制。（保证线程数可控，不会造成线程过多，导致系统负载更为严重）
newSingleThreadExecutor：创建一个单线程的线程池，适用于需要保证顺序执行各个任务。
newScheduledThreadPool：适用于执行延时或者周期性任务。

七、代码实例

1、四种常见线程池

package com.guor.thread;

import java.util.Date;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class Handle implements Runnable {
    private String name;

    public Handle(String name) {
        this.name = "Thread" + name;
    }

    @Override
    public void run() {
        System.out.println(name + "-> start time : " + new Date());
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(name + "-> end time : " + new Date());
    }

    public static void main(String[] args) throws InterruptedException {
        scheduledTest();
    }

    //可缓存的线程池
    private static void cacheTest() {
        ExecutorService newCachedThreadPool = Executors.newCachedThreadPool();
        for (int i = 0; i < 10; i++) {
            Handle handle = new Handle(String.valueOf(i));
            newCachedThreadPool.execute(handle);
        }
        newCachedThreadPool.shutdown();
        System.out.println("Main Thread: Finished at:" + new Date());
    }

    //固定长度的线程池
    private static void fixedTest() {
        ExecutorService newFixedThreadPool = Executors.newFixedThreadPool(5);
        for (int i = 0; i < 10; i++) {
            Handle handle = new Handle(String.valueOf(i));
            newFixedThreadPool.execute(handle);//先执行五个，然后再执行五个
        }
        newFixedThreadPool.shutdown();
        System.out.println("Main Thread: Finished at:" + new Date());
    }

    //单线程线程池
    private static void singleTest() {
        ExecutorService newSingleThreadExecutor = Executors.newSingleThreadExecutor();
        for (int i = 0; i < 10; i++) {
            Handle handle = new Handle(String.valueOf(i));
            newSingleThreadExecutor.execute(handle);//单一线程分次执行
        }
        newSingleThreadExecutor.shutdown();
        System.out.println("Main Thread: Finished at:" + new Date());
    }

    /**
     * 固定长度的线程池，而且以延迟或者定时的方式来执行，类似Timer
     *
     * scheduleAtFixedRate 按指定频率周期执行某个任务
     * scheduleAtFixedRate ，是以上一个任务开始的时间计时，period时间过去后，检测上一个任务是否执行完毕，
     * 如果上一个任务执行完毕，则当前任务立即执行，如果上一个任务没有执行完毕，则需要等上一个任务执行完毕后立即执行。
     *
     * scheduleWithFixedDelay 周期定时执行某个任务/按指定频率间隔执行某个任务(注意)
     * scheduleWithFixedDelay，是以上一个任务结束时开始计时，period时间过去后，立即执行。
     *
     */
    private static void scheduledTest() {
        ScheduledExecutorService newScheduledThreadPool = Executors.newScheduledThreadPool(10);
        for (int i = 0; i < 3; i++) {
            Handle handle = new Handle(String.valueOf(i));
            //执行
            //newScheduledThreadPool.execute(handle);
            //延迟1秒执行
            //newScheduledThreadPool.schedule(handle, 1, TimeUnit.SECONDS);
            //延迟1秒，每隔3秒执行一遍（隔3秒执行，①如果上一次结束，立即执行；②如果上一次未结束，结束立即执行；）
            //newScheduledThreadPool.scheduleAtFixedRate(handle, 1, 3, TimeUnit.SECONDS);
            //延迟1秒，每隔3秒执行一遍(上一个任务结束开始计时)
            newScheduledThreadPool.scheduleWithFixedDelay(handle, 1, 3, TimeUnit.SECONDS);
        }
        //newScheduledThreadPool.shutdown();
        System.out.println("Main Thread: Finished at:" + new Date());
    }
}

2、控制台输出

3、Callable方式开启多线程

package com.guor.thread;

import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class TaskWithResult implements Callable<String> {
    private int id;

    public TaskWithResult(int id) {
        this.id = id;
    }

    @Override
    public String call() throws Exception {
        System.out.println("call()方法被自动调用,干活！！！             " + Thread.currentThread().getName());
        Thread.sleep(2000);
        return "call()方法被自动调用，任务的结果是：" + id + "    " + Thread.currentThread().getName();
    }

    public static void main(String[] args) throws InterruptedException, ExecutionException {
        ExecutorService newCachedThreadPool = Executors.newCachedThreadPool();
        List<Future<String>> list = new ArrayList<Future<String>>();
        // 创建10个任务并执行
        for (int i = 0; i < 10; i++) {
            //使用ExecutorService执行Callable类型的任务，并将结果保存在future变量中
            Future<String> future = newCachedThreadPool.submit(new TaskWithResult(i));
            //将任务执行结果存储到List中
            list.add(future);
        }

        //启动一次顺序关闭，执行以前提交的任务，但不接受新任务。如果已经关闭，则调用没有其他作用。
        newCachedThreadPool.shutdown();
        for(Future<String> future : list) {
            System.out.println(future.get() + "--date--> " +new Date());
        }
    }
}