java服务端（一）线程池

最新推荐文章于 2024-05-15 15:12:57 发布

qq_40191710

最新推荐文章于 2024-05-15 15:12:57 发布

阅读量296

点赞数

分类专栏： java服务端

java服务端专栏收录该内容

14 篇文章 0 订阅

订阅专栏

线程池中的四个构造方法：

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

二：
public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime,
                          TimeUnit unit, BlockingQueue<Runnable> workQueue,
                          ThreadFactory threadFactory) {
        this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
             threadFactory, defaultHandler);
}

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

四：
public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime,
                          TimeUnit unit, BlockingQueue<Runnable> workQueue,
                          ThreadFactory threadFactory, RejectedExecutionHandler handler) {
        if (corePoolSize < 0 ||
            maximumPoolSize <= 0 ||
            maximumPoolSize < corePoolSize ||
            keepAliveTime < 0)
            throw new IllegalArgumentException();
        if (workQueue == null || threadFactory == null || handler == null)
            throw new NullPointerException();
        this.acc = System.getSecurityManager() == null ?
                null :
                AccessController.getContext();
        this.corePoolSize = corePoolSize;
        this.maximumPoolSize = maximumPoolSize;
        this.workQueue = workQueue;
        this.keepAliveTime = unit.toNanos(keepAliveTime);
        this.threadFactory = threadFactory;
        this.handler = handler;
}

由上面的方法可知：前三个方法后调用第四个方法。

各个参数的意义：

corePoolSize：核心池的大小

在创建线程池后，默认情况下，线程池中并没有任何线程。线程池中的线程数为0，当有任务来之后，就会创建一个线程去执行任务。当线程池中的线程数目达到corePoolSize后，就会把达到的任务放到缓存队列中。

maximumPoolSize：

线程池最大线程数，表示在线程池中最多能创建多少个线程。

KeepAliveTime：

表示线程没有任务执行最多保持多长时间就会终止。

unit：

参数keepAliveTime的时间单位，有其中取值。

TimeUnit.DAYS;               //天
TimeUnit.HOURS;             //小时
TimeUnit.MINUTES;           //分钟
TimeUnit.SECONDS;           //秒
TimeUnit.MILLISECONDS;      //毫秒
TimeUnit.MICROSECONDS;      //微妙
TimeUnit.NANOSECONDS;       //纳秒

workQueue：阻塞队列

用来存储等待执行的任务。有三种队列

（1）ArrayBlockingQueue; （2）LinkedBlockingQueue; （3）SynchronousQueue;

threadFactory：

线程共产，用来创建线程。

handler：

表示当拒绝处理任务时的策略，有四种取值：

（1）ThreadPoolExecutor.AbortPolicy:丢弃任务并抛出RejectedExecutionException异常。
（2）ThreadPoolExecutor.DiscardPolicy：也是丢弃任务，但是不抛出异常。
（3）ThreadPoolExecutor.DiscardOldestPolicy：丢弃队列最前面的任务，然后重新尝试执行任务（重复此过程）
（4）ThreadPoolExecutor.CallerRunsPolicy：由调用线程处理该任务

线程继承关系图：

Executor ：

是一个顶层接口，只声明了一个方法 execute（Runnable），返回值为void，参数为Runnable类型，用来执行传进去的任务。

线程的操作：

1、线程池状态：

volatile int runState;
static final int RUNNING    = 0;
static final int SHUTDOWN   = 1;
static final int STOP       = 2;
static final int TERMINATED = 3;

runState表示当前线程池的状态，它是一个volatile变量办证线程之间的可见性。

RUNNING：线程池创建后，初始时，线程池处于RUNNING状态。

SHUTDOWN：调用shutdown，线程池处于SHUTDOWN状态，此时线程池不能够接收新的任务，它会等待所有任务执行完毕。

STOP：如果调用了shutdownNow()方法，则线程池处于STOP状态，此时线程池不能接受新的任务，并且会去尝试终止正在执行的任务；

　　TERMINATED：当线程池处于SHUTDOWN或STOP状态，并且所有工作线程已经销毁，任务缓存队列已经清空或执行结束后，线程池被设置为TERMINATED状态。

2、任务的执行：

ThreadPoolExcutor类中比较重要的成员变量：

private final BlockingQueue<Runnable> workQueue;              //任务缓存队列，用来存放等待执行的任务

private final ReentrantLock mainLock = new ReentrantLock();   //线程池的主要状态锁，对线程池状态（比如线程池大小
                                                              //、runState等）的改变都要使用这个锁

private final HashSet<Worker> workers = new HashSet<Worker>();  //用来存放工作集
 
private volatile long  keepAliveTime;    //线存活货时间   

private volatile boolean allowCoreThreadTimeOut;   //是否允许为核心线程设置存活时间

private volatile int   corePoolSize;     //核心池的大小（即线程池中的线程数目大于这个参数时，提交的任务会被放进任务缓存队列）

private volatile int   maximumPoolSize;   //线程池最大能容忍的线程数
 
private volatile int   poolSize;       //线程池中当前的线程数
 
private volatile RejectedExecutionHandler handler; //任务拒绝策略
 
private volatile ThreadFactory threadFactory;   //线程工厂，用来创建线程
 
private int largestPoolSize;   //用来记录线程池中曾经出现过的最大线程数
 
private long completedTaskCount;   //用来记录已经执行完毕的任务个数OWN或STOP状态，并且所有工作线程已经销毁，任务缓存队列已经清空或执行结束后，线程池被设置为TERMINATED状态。

corePoolSize、maximumPoolSize、largestPoolSize三个变量的区别。

距离解释：

假如有一个工厂，工厂里面有10个工人，每个工人同时只能做一件任务。

　　因此只要当10个工人中有工人是空闲的，来了任务就分配给空闲的工人做；

　　当10个工人都有任务在做时，如果还来了任务，就把任务进行排队等待；

　　如果说新任务数目增长的速度远远大于工人做任务的速度，那么此时工厂主管可能会想补救措施，比如重新招4个临时工人进来；

　　然后就将任务也分配给这4个临时工人做；

　　如果说着14个工人做任务的速度还是不够，此时工厂主管可能就要考虑不再接收新的任务或者抛弃前面的一些任务了。

　　当这14个工人当中有人空闲时，而新任务增长的速度又比较缓慢，工厂主管可能就考虑辞掉4个临时工了，只保持原来的10个工人，毕竟请额外的工人是要花钱的。

　　这个例子中的corePoolSize就是10，而maximumPoolSize就是14（10+4）。

　　也就是说corePoolSize就是线程池大小，maximumPoolSize在我看来是线程池的一种补救措施，即任务量突然过大时的一种补救措施。

largestPoolSize只是一个用来起记录作用的变量，用来记录线程池中曾经有过的最大线程数目，跟线程池的容量没有任何关系。

3、

4、

5、

java的四种线程池：

newCachedThreadPool创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。
newFixedThreadPool 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。
newScheduledThreadPool 创建一个定长线程池，支持定时及周期性任务执行。
newSingleThreadExecutor 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。

（1）newCachedThreadPool 创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程：

线程池工作原理：

创建线程池的时候一开始会初始化好几个线程，会给每一个线程分配一个工作（任务）队列。当 run 的时候就会从任务队列中取出一个任务，如果有任务，执行线程的run方法，如果没有任务，则进行阻塞队列，直到工作队列有新的任务进来。才继续取出一个任务。

如果线程池中有多个工作队列就是如下所示（下图假设有这个线程池有三个工作队列+3个线程），会有顺序分配到三个队列，这三个队列是并发的执行。

结论：

一个Thread + 一个队列 == 一个单线程的线程池 =====> 线程安全。任务时线性串行执行的

转载参考自：

https://www.cnblogs.com/dolphin0520/p/3932921.html

https://www.cnblogs.com/ruiati/p/6134131.html

qq_40191710

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
java服务端（一）线程池

线程池中的四个构造方法：构造方法一：public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue) { t...
复制链接

扫一扫