线程池的基础与操作

Posted 2020-12-27 television

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了线程池的基础与操作相关的知识，希望对你有一定的参考价值。

一、概念

使用ThreadPoolExecutor类：包含了五个参数int corePoolSize(线程池的基本大小）,int maximumPoolSize（最大线程池容量）,long keepAliveTime（存活时间）,TimeUnit unit（时间单位）, BlockingQueue<Runnable> workQueue（任务队列）

　　　　corePoolSize:当线程池刚刚创建的时候，线程池中没用线程，当有任务创建且当前线程数小于corePoolSize时才会去创建新的线程。但是当调用prestartAllCoreThreads或prestartCoreThread方法时候才会在创建时就创建corePoolSize个或一个线程。当创建的线程数等于corePoolSize时，就不再创建新线程，而是放到缓存队列中，当缓存队列（缓存队列的大小通过BlockingQueue来设置）满了的时候，才开始创建新的线程。

　　　　maximumPoolSize:线程创建的最大数，当线程数未达到该值，并且任务队列已满，就可以新创建线程。

　　　　　　　　　　　　　当线程达到maximumPoolSize，并且队列也已经满了，如果再有新任务就会采取饱和策略，默认采取AbortPolicy，用来抛出异常，表示不能再处理新的任务。

　　　　　　　　　　　　　有四种策略：

CallerRunsPolicy：只用调用者所在线程来运行任务。
DiscardOldestPolicy：丢弃队列里最近的一个任务，并执行当前任务。
DiscardPolicy：不处理，丢弃掉。
当然也可以根据应用场景需要来实现RejectedExecutionHandler接口自定义策略。如记录日志或持久化不能处理的任务。

　　　　keepAliveTime:线程池的工作线程空闲后，保持存活的时间。所以如果任务很多，并且每个任务执行的时间比较短，可以调大这个时间，提高线程的利用率,避免重复的创建销毁线程。

　　　　TimeUnit:时间单位：线程keepAliveTime的时间单位

　　　　BlockingQueue：任务缓存队列，用于保存线程数达到corePoolSize之后的阻塞队列。可以选择以下几种阻塞队列：

　　　　1.ArrayBlockingQueue：是一个基于数组结构的有界阻塞队列，此队列按 FIFO（先进先出）原则对元素进行排序。

　　　　2.LinkedBlockingQueue：一个基于链表结构的阻塞队列，此队列按FIFO （先进先出）排序元素，吞吐量通常要高于ArrayBlockingQueue。静态工厂方法Executors.newFixedThreadPool()使用了这个队列。

　　　　3.SynchronousQueue：一个不存储元素的阻塞队列。每个插入操作必须等到另一个线程调用移除操作，否则插入操作一直处于阻塞状态，吞吐量通常要高于LinkedBlockingQueue，静态工厂方法Executors.newCachedThreadPool使用了这个队列。

　　　　4.PriorityBlockingQueue：一个具有优先级得无限阻塞队列。

流程图：

技术分享图片

二、操作

　　1、线程池创建：

ThreadPoolExecutor executor = new ThreadPoolExecutor(2, 10, 200, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(5));

　　2、使用线程池执行任务

//execute中的参数是一个runnable接口实例
threadsPool.execute(new Runnable() {
public void run(){
    }
}

//也可以使用一个实例先实现runnable
Class task implements Runnable(){
     public void run(){
    
    }   
}       

threadsPool.execute(task);

3、简单的线程例子

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class Test {
    public static void main(String[] args) {
        ThreadPoolExecutor executor = new ThreadPoolExecutor(2, 10, 200, TimeUnit.MILLISECONDS,
                new ArrayBlockingQueue<Runnable>(5));

        for(int i=0;i<15;i++){
            MyTask myTask = new MyTask(i);
            executor.execute(myTask);
            System.out.println("线程池中线程数目："+executor.getPoolSize()+"，队列中等待执行的任务数目："+
                    executor.getQueue().size()+"，已执行玩别的任务数目："+executor.getCompletedTaskCount());
        }
        executor.shutdown();
    }
}


class MyTask implements Runnable {
    private int taskNum;

    public MyTask(int num) {
        this.taskNum = num;
    }

    @Override
    public void run() {
        System.out.println("正在执行task "+taskNum);
        try {
            Thread.currentThread().sleep(4000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("task "+taskNum+"执行完毕");
    }
}