Java多线程（五）线程池

·什么是线程池，为什么要用线程池？

　　1.降低资源的消耗，降低线程创建时间和销毁的资源消耗

　　2.提高响应速度，线程创建的时间为T1，执行时间T2，销毁时间T3

　　3.提高线程的管理性

·实现一个自己的线程池

　　1.线程必须在池子里面已经创建好了，并且可以包吃住，要有容器保存更多的线程

　　2.线程还要能够接受外部的任务，运行这个任务，容器保持这个来不及运行的任务

package thread.ThreadPool;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingDeque;
import java.util.concurrent.BlockingQueue;

/**
 * 自己实现的线程池
 */
public class MyThreadPool {

    //线程池中默认的线程的个数为5
    private static int WORK_NUM = 5;
    //队列默认任务个数为10
    private static int TASK_COUNT = 10;

    //工作线程
    private WorkThread[] workThreads;

    //任务队列，作为一个缓冲
    private final BlockingQueue<Runnable> taskQueue;
    private final int worker_num;

    public MyThreadPool(int worker_num, int taskCount) {
        if (worker_num<0) worker_num = WORK_NUM;
        if (taskCount<0) taskCount = TASK_COUNT;
        this.worker_num = worker_num;
        taskQueue = new ArrayBlockingQueue<>(taskCount);
        workThreads = new WorkThread[worker_num];
        for (int i = 0; i < worker_num; i++) {
            workThreads[i] = new WorkThread();
            workThreads[i].start();
        }
    }

    public MyThreadPool() {
        this(WORK_NUM,TASK_COUNT);
    }

    //执行任务，其实就是把任务加入任务队列，什么时候执行由线程管理器决定
    public void execute(Runnable task){
        try {
            taskQueue.put(task);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }


    /*
    内部类，工作线程
     */
    private class WorkThread extends Thread{
        @Override
        public void run() {
            Runnable r = null;
            try{
                while(!isInterrupted()){
                    r = taskQueue.take();
                    if (r!=null){
                        System.out.println(getId()+"ready execute"+r);
                        r.run();
                    }
                    r = null;//help GC
                }
            }catch (InterruptedException e) {
                e.printStackTrace();
            }

        }

        public void stopWorker(){
            interrupt();
        }
    }


}


·JDK线程池
主要实现ThreadPoolExecutor，所有线程池实现的父类
各个参数的含义

int corePoolSize,线程池中核心线程数，如果当前线程数小于corePoolSize就会创建新线程，否则保存到BlockingQueue
　　　　　　　　　　prestartAllCoreThreads（）方法就会一次性启动corePoolSize个数的线程

int maximumPoolSize,允许的最大线程数，如果BlockingQueue也满了，当前线程数小于maximumPoolSize时也会创建新线程

long keepAliveTime,线程空闲下来后存活的时间，只有在大于Corepoolsize时才有用

TimeUnit unit,时间单位值
BlockingQueue<Runnable> workQueue,保存任务的阻塞队列
THreadFactory， 创建线程的工厂，给新的线程赋名字
RejectedExecutionHandler handler：饱和策略
　　AbortPolicy：直接抛出异常，默认
　　CallerRunsPolicy：用调用者的线程来执行任务
　　DiscardOldestPolicy:丢弃阻塞队列中最老的任务
　　DiscardPolicy：当前任务直接丢弃

Java多线程（五）线程池

原文：https://www.cnblogs.com/moxi-moxi/p/12828467.html