Java线程池和自定义线程池

**本文内容为以下教程视频总结而成。https://www.bilibili.com/video/BV18J41157DX

线程池

线程池是一种线程使用模式。在线程池中维护着多个线程，等待着监督管理者分配可并发执行的任务。这避免了在处理短时间任务时创建与销毁线程的代价。使用线程池不仅能够保证内核的充分利用，还能防止过分调度。WEB服务器完成网页请求这样的任务，使用线程池技术是非常合适的。

线程池基础

线程池是一种多线程的处理形式，处理过程可以将任务添加到队列，创建线程后自动启动这些任务。这里的任务是实现了Runnable或Callable接口的实例对象。

为什么使用线程池？
使用线程池可以根据需求和硬件灵活控制线程的数量，并且可以对线程进行统一的管理和控制从而提高系统运行效率。降低系统压力。

使用线程池有哪些优势？

1. 线程和任务分离，提升线程的复用性
2. 控制线程并发数量，根据服务器状态可以用于降低服务器压力。
3. 提升响应速度，当线程池内有空闲线程池，省去传统创建和销毁线程池的步骤，进而提升响应速度。

应用场景

1. 网购商品秒杀
2. 网上购票系统

线程池的使用

首先我们观察Java中ThreadPoolExecutor来学习线程池的原理。

构造方法核心参数
根据ThreadPoolExecutor源码构造函数，下面总结了几个构造线程池的常见参数

int corePoolSize //核心线程数量
int maximumPoolSize //最大线程数
long keepAliveTime //最大空闲时间
TimeUnit unit //时间单位
BlockingQueue< Runnable> workQueue //任务队列
ThreadFactory threadFactory //线程工厂
RejectedExecutionHandler handler //饱和处理机制

流程示意图如下：

自定义线程池

1. 创建任务类，实现Runnable接口

public class MyTask implements Runnable {
    private int id; //定义成员变量任务ID

    public MyTask(int id){
        this.id=id;
        System.out.println("任务"+id+" 已被创建");
    }

    public int getId() {
        return id;
    }
    @Override
    public void run() {
        String name = Thread.currentThread().getName();
        System.out.println("线程：" + name + "将执行任务" + id);

        //模拟执行任务时间0.5s
        try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("线程：" + name + "完成任务" + id);

    }
}

2. 创建线程类，用于处理任务，需要持有任务

import java.util.List;

public class MyThread extends Thread {
    //定义成员变量name
    private String name;
    //定义集合用于保存所有任务
    private List<Runnable> tasks;
    //构造函数
    public MyThread(String name, List<Runnable> tasks) {
        super(name);
        this.tasks = tasks;
    }

    @Override
    public void run() {
        //判断任务集合中是否有任务,有的话则取出并调用任务类的run方法，交给线程执行
        while(tasks.size()>0){
            Runnable runnable = tasks.remove(0);
            runnable.run();
        }
    }
}

3. 编写线程池类，应包含提交，执行任务的功能，并设计任务队列
   根据前面所描述的核心参数，我们在设计线程池的时候，应当设计一下变量

• 当前线程数量
• 核心线程数量
• 最大线程数量
• 任务队列
• 任务队列长度

这里要特别注意的是，任务队列可能会被多个线程同时访问，因此应当考虑线程安全问题。

import java.util.Collections;
import java.util.LinkedList;
import java.util.List;

public class MyThreadPool {
    //任务队列，需要控制线程安全问题
    private List<Runnable> tasks = Collections.synchronizedList(new LinkedList<>());
    private int currNum; //当前任务数量
    private int corePoolSize; //核心线程数
    private int maxSize; //最大线程数
    private int workSize; //任务队列长度

    //构造函数
    public MyThreadPool(int corePoolSize, int maxSize, int workSize) {
        this.corePoolSize = corePoolSize;
        this.maxSize = maxSize;
        this.workSize = workSize;
    }

    //提交任务
    public void submit(Runnable r){
        //判断队列中任务数量是否超过最大队列长度
        if (tasks.size()>=workSize){
            System.out.println("任务队列已满，任务"+r+"已经被抛弃");
        }else{
            tasks.add(r);
            executeTask(r);
        }
    }
    //执行任务
    private void executeTask(Runnable r) {
        //判断当前线程池中的线程总数是否超出核心线程数
        if (currNum < corePoolSize){
            new MyThread("核心线程："+currNum, tasks).start();
            currNum++;
        }else if (currNum<maxSize){
            new MyThread("非核心线程:"+currNum, tasks).start();
            currNum++;
        }else {
            System.out.println("任务"+r+"被放入任务队列");
        }
    }
}

最后编写测试类

public class Test {
    public static void main(String[] args) {
        //创建线程池对象，设定基本参数
        MyThreadPool pool=new MyThreadPool(10,20,20);
        //创建100个任务
        for (int i = 1; i <= 100; i++) {
            try {
                MyTask my = new MyTask(i);
                //将创建的任务提交到线程池
                pool.submit(my);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}

Java内置线程池-ExecutorService

ExecutorService接口是java内置的线程池接口，其常用方法如下：

//关闭，执行以前已经提交的任务，但不再接受新任务
void shutdown()

//停止所有正在执行的任务，暂停处理正在等待的任务，并返回等待执行的任务列表
List< Runnable> shutdownNow()

//执行带返回值的任务，并返回一个Future对象
<T> Future<T> submit(Callable<T> task)

//执行Runnable任务，并返回一个表示该任务的Future
Future< ?> submit(Runnable task)

//执行Runnable任务，并返回一个表示该任务的Future
<T> Future<T> submit(Runnable task, T result)

ExecutorService获取

可以通过JDK中的Executors类（工具类）中的静态方法来获取ExecutorService

//新建一个默认线程池对象，线程可以复用，线程数量不限制
static ExecutorService newCachedThreadPool()
//线程池中所有线程都适用ThreadFactory来创建，线程无需手动启动
static ExecutorService newCachedThreadPool(ThreadFactory threadFactory)

//可重用固定线程数线程池
static ExecutorService newFixedThreadPool(int nThreads)
//线程将通过ThreadFactory创建，同上
static ExecutorService newFixedThreadPool(int nThreads， ThreadFactory threadFactory)

//创建一个使用单个worker线程的Executor，队列无界，安全性能高
static ExecutorService newSingleThreadExecutor()
//同上
static ExecutorService newSingleThreadExecutor(ThreadFactory threadFactory)

ScheduledExectuorService获取

ScheduledExecutorService是ExecutorService的子接口，具备延迟运行或定期执行任务的能力。

静态方法获取方式如下:

//可重用固定线程数的线程池且允许延迟运行或定期执行任务
static ScheduledExecutorService newScheduledThreadPool(int corePoolSize)

//可重用固定线程数的线程池，线程由ThreadFactory来创建且允许延迟运行或定期执行任务
static ScheduledExecutorService newScheduledThreadPool(int corePoolSize, ThreadFactory threadFactory)

//创建一个单线程执行程序
static ScheduledExecutorService newSingleThreadScheduledExecutor()

//同上，线程由ThreadFactory创建
static ScheduledExecutorService newSingleThreadScheduledExecutor(ThreadFactory threadFactory)

其常用方法如下:

public <V> ScheduledFuture<V> schedule(Callable<V> callable, long delay, TimeUnit unit);

public ScheduledFuture<?> schedule(Runnable command, long delay, TimeUnit unit);

//延迟initialDelay的时间后，每间隔period时间重复一次
public ScheduledFuture<?> scheduleAtFixedRate(Runnable command, long initialDelay, long period, TimeUnit unit);

//执行上一次操作后，下一次都存在给定的延迟
public ScheduledFuture<?> scheduleWithFixedDelay(Runnable command, long initialDelay, long delay, TimeUnit unit);

Java内置线程池 异步计算结果(Future)

常用方法

//试图取消此任务，成功返回true
boolean cancel(boolean mayInterruptIfRunning);
//如果在正常完成之前取消，返回true
boolean isCancelled();
//如果任务已经完成，返回true
boolean isDone();
//等待计算结果
V get() throws InterruptedException, ExecutionException;
//等待计算结果， 并设定最大等待时间
V get(long timeout, TimeUnit unit)
        throws InterruptedException, ExecutionException, TimeoutException;