并发编程 - 线程池

为什么要用线程池？

第一：降低资源消耗
第二：提高响应速度。
第三：提高线程的可管理性。

ThreadPoolExecutor

Executor 是一个接口，它是Executor 框架的基础，它将任务的提交与任务的执行分离开来。
ExecutorService 接口继承了Executor，在其上做了一些shutdown()、submit()的扩展，可以说是真正的线程池接口；
AbstractExecutorService 抽象类实现了ExecutorService 接口中的大部分方法；
ThreadPoolExecutor 是线程池的核心实现类，用来执行被提交的任务。
ScheduledExecutorService 接口继承了ExecutorService 接口，提供了带"周期执行"功能ExecutorService；
ScheduledThreadPoolExecutor 是一个实现类，可以在给定的延迟后运行命令，或者定期执行命令。ScheduledThreadPoolExecutor 比Timer 更灵活，功能更强大。

线程池的创建各个参数含义

public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,BlockingQueue workQueue,ThreadFactory threadFactory,RejectedExecutionHandler handler)

corePoolSize： 线程池中的核心线程数
maximumPoolSize：线程池中允许的最大线程数
keepAliveTime： 线程空闲时的存活时间，即当线程没有任务执行时，继续存活的时间
TimeUnit： keepAliveTime 的时间单位
workQueue： workQueue 必须是BlockingQueue 阻塞队列。当线程池中的线程数超过它的corePoolSize 的时候，线程会进入阻塞队列进行阻塞等待。通过workQueue，线程池实现了阻塞功能
threadFactory： 创建线程的工厂，通过自定义的线程工厂可以给每个新建的线程设置一个具有识别度的线程名，当然还可以更加自由的对线程做更多的设置，比如设置所有的线程为守护线程。
RejectedExecutionHandler： 线程池的饱和策略
（1）AbortPolicy：直接抛出异常，默认策略；
（2）CallerRunsPolicy：用调用者所在的线程来执行任务；
（3）DiscardOldestPolicy：丢弃阻塞队列中靠最前的任务，并执行当前任务；
（4）DiscardPolicy：直接丢弃任务；

工作机制

1）如果当前运行的线程少于corePoolSize，则创建新线程来执行任务（注意，执行这一步骤需要获取全局锁）。
2）如果运行的线程等于或多于corePoolSize，则将任务加入BlockingQueue。
3）如果无法将任务加入BlockingQueue（队列已满），则创建新的线程来处理任务。
4）如果创建新线程将使当前运行的线程超出maximumPoolSize，任务将被拒绝，并调用RejectedExecutionHandler.rejectedExecution()方法。

提交任务

execute()方法用于提交不需要返回值的任务，所以无法判断任务是否被线程池执行成功。

submit()方法用于提交需要返回值的任务。线程池会返回一个future 类型的对象，通过这个future 对象可以判断任务是否执行成功，并且可以通过future的get()方法来获取返回值，get()方法会阻塞当前线程直到任务完成，而使用get（long timeout，TimeUnit unit）方法则会阻塞当前线程一段时间后立即返回，这时候有可能任务没有执行完。

合理地配置线程池

CPU 密集型任务应配置尽可能小的线程，如配置Ncpu+1 个线程的线程池。由于IO 密集型任务线程并不是一直在执行任务，则应配置尽可能多的线程，如2*Ncpu。

预定义线程池

FixedThreadPool 详解
创建使用固定线程数的FixedThreadPool 的API。适用于为了满足资源管理的需求，而需要限制当前线程数量的应用场景，它适用于负载比较重的服务器。
SingleThreadExecutor
创建使用单个线程的SingleThread-Executor 的API，于需要保证顺序地执行各个任务；并且在任意时间点，不会有多个线程是活动的应用场景。
CachedThreadPool
创建一个会根据需要创建新线程的CachedThreadPool 的API。大小无界的线程池，适用于执行很多的短期异步任务的小程序，或者是负载较轻的服务器。

一、手写线程池

import java.util.List;

/**
 * 线程接口
 *
 * @Author yjian
 * @Date 14:49 2017/10/14
 **/
public interface IThreadPool {
    //加入任务
    void execute(Runnable task);

    //加入任务
    void execute(Runnable[] tasks);

    //加入任务
    void execute(List<Runnable> tasks);

    //销毁线程
    void destroy();
}

import java.util.LinkedList;
import java.util.List;
import java.util.concurrent.atomic.AtomicLong;

/**
 * 线程实现类（简易实现，自行优化.提供思路）
 *
 * @Author yjian
 * @Date 14:49 2017/10/14
 **/
@SuppressWarnings("ALL")
public class ThreadPoolImpl implements IThreadPool {
    //默认开启线程个数
    static int WORKER_NUMBER = 5;
    //完成任务线程数 可见性
    static volatile int sumCount = 0;
    //任务队列 list非线程安全，可以优化为BlockingQueue
    static List<Runnable> taskQueue = new LinkedList<Runnable>();
    //线程工作组
    WorkerThread[] workThreads;
    //原子性
    static AtomicLong threadNum = new AtomicLong();

    static ThreadPoolImpl threadPool;

    //构造方法
    public ThreadPoolImpl() {
        this(WORKER_NUMBER);
    }

    public ThreadPoolImpl(int workerNum) {
        this.WORKER_NUMBER = workerNum;
        //开辟工作线程空间
        workThreads = new WorkerThread[WORKER_NUMBER];
        //开始创建工作线程
        for (int i = 0; i < WORKER_NUMBER; i++) {
            workThreads[i] = new WorkerThread();
            Thread thread = new Thread(workThreads[i], "ThreadPool-worker" + threadNum.incrementAndGet());
            System.out.println("初始化线程数" + (i + 1) + "---------当前线程名称:" + thread.getName());
            thread.start();
        }
    }

    @Override
    public String toString() {
        return "工作线程数量为" + WORKER_NUMBER
                + "已完成的任务数" + sumCount +
                "等待任务数量" + taskQueue.size();
    }


    //获取线程池
    public static IThreadPool getThreadPool() {
        return getThreadPool(WORKER_NUMBER);
    }

    public static IThreadPool getThreadPool(int workerNum) {
        //容错性，如果小于等于0就默认线程数
        if (workerNum <= 0) {
            workerNum = WORKER_NUMBER;
        }
        if (threadPool == null) {
            threadPool = new ThreadPoolImpl(workerNum);
        }
        return threadPool;
    }


    @Override
    public void execute(Runnable task) {
        synchronized (taskQueue) {
            taskQueue.add(task);
            taskQueue.notifyAll();
        }
    }

    @Override
    public void execute(Runnable[] tasks) {
        synchronized (taskQueue) {
            for (Runnable task : tasks) {
                taskQueue.add(task);
            }
            taskQueue.notifyAll();
        }
    }

    @Override
    public void execute(List<Runnable> tasks) {
        synchronized (taskQueue) {
            for (Runnable task : tasks) {
                taskQueue.add(task);
            }
            taskQueue.notifyAll();
        }
    }

    @Override
    public void destroy() {
        //循环是否还存在任务，如果存在等待20毫秒处理时间
        while (!taskQueue.isEmpty()) {
            try {
                Thread.sleep(20);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //如果任务队列已处理完成，销毁线程，清空任务
        for (int i = 0; i < WORKER_NUMBER; i++) {
            workThreads[i].setWorkerFlag();
            workThreads[i] = null;
        }
        threadPool = null;
        taskQueue.clear();
    }

    //创建工作线程池
    class WorkerThread extends Thread {
        //用来标识当前线程属于活动可用状态
        private boolean isRunning = true;

        @Override
        public void run() {
            Runnable runnable = null;
            //死循环
            while (isRunning) {
                //非线程安全，所以采用同步锁
                synchronized (taskQueue) {
                    while (isRunning && taskQueue.isEmpty()) {
                        try {
                            //如果任务队列为空，等待20毫秒 监听任务到达
                            taskQueue.wait(20);
                        } catch (Exception e) {
                            e.printStackTrace();
                        }
                    }
                    //任务队列不为空
                    if (!taskQueue.isEmpty()) {
                        runnable = taskQueue.remove(0);//获取第一个任务
                    }
                }
                if (runnable != null) {
                    runnable.run();
                }
                sumCount++;
                runnable = null;
            }
        }

        //销毁线程
        public void setWorkerFlag() {
            isRunning = false;
        }
    }
}

import java.util.ArrayList;
import java.util.List;

/**
 * 测试类
 *
 * @Author yjian
 * @Date 15:37 2017/10/14
 **/
public class ThreadPoolTest {


    public static void main(String[] args) {
        //获取线程池
        IThreadPool t = ThreadPoolImpl.getThreadPool(20);

        List<Runnable> taskList = new ArrayList<Runnable>();
        for (int i = 0; i < 100; i++) {
            taskList.add(new Task());
        }
        //执行任务
        t.execute(taskList);
        System.out.println(t);
        //销毁线程
        t.destroy();
        System.out.println(t);
    }

    static class Task implements Runnable {

        private static volatile int i = 1;

        @Override
        public void run() {
            System.out.println("当前处理的线程:" + Thread.currentThread().getName() + " 执行任务" + (i++) + " 完成");
        }
    }
}

原文链接：https://blog.csdn.net/yingfengjia520/article/details/78234739