线程池内部实现

最新推荐文章于 2022-08-19 19:12:18 发布

欣淡定

最新推荐文章于 2022-08-19 19:12:18 发布

阅读量221

点赞数

分类专栏：并发程序文章标签：线程池内部实现线程池队列

本文链接：https://blog.csdn.net/xindanding/article/details/103885699

版权

并发程序专栏收录该内容

10 篇文章 0 订阅

订阅专栏

之前已经介绍过newFixedThreadPool,newCachedThreadPool,newSingleThreadScheduledExecutor等线程池;这些线程池底层都是用了ThreadPoolExecutor实现.

比如public static ExecutorService newFixedThreadPool(int nThreads){

return new ThreadPoolExecutor(nThreads,

nThreads, 0L,

TimeUnit.MILLISECONDS,

newLinkedBlockingQueue<Runnable>());

}

public static ExecutorService newCachedThreadPool(){

return new ThreadPoolExecutor(0,

Integer.MAX_VALUE,

60L,

TimeUnit.SECONDS,

new SynchronousQueue<Runnable>());

}

而ThreadPoolExecutor中主要的构造函数就是:

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

corePoolSize:核心线程数,指定线程池中初始的线程数量

maximumPoolSize:指定线程池中最大的线程数量

keepAliveTime: 当线程数量大于corePoolSize时,多余的空闲线程存活时间

unit:多余空闲线程存活时间单位, 毫秒,秒....

workQueue:任务队列,存放被提交但尚未被执行的任务

threadFactory:线程工厂,创建线程 ,一般使用默认的即可

handler:拒绝策略.当任务大于最大线程数时,对于多余的任务所采取的处理方式

1.主要队列:

直接提交队列SynchronousQueue: 提交的任务不会被保存,而是生成一个新的线程处理任务;如果线程出已经达到最大值,

则执行拒绝策略,通常设置一个很大的maximumPooliSize;

有界队列ArrayBlockingQueue: 如果系统线程数小于corePoolSize,则使用线程池中的空闲线程;

如果系统线程数大于corePoolSize,则将提交的任务放置队列中,直到队列满了,则生成新的线程处理任务,

直到系统线程数大于maximumPoolSize,则执行拒绝策略

无界队列LinkedBlockQueue: 与有界队列ArrayBlockingQueue的区别就是,队列满后,一直会生成新的线程

处理任务,直到耗尽系统资源

优先任务队列PriorityBlockingQueue: 与ArrayBlockingQueue,LinkedBlockingQueue都是按照先进先出算法处理相比,

PriorityBlockingQueue可以根据任务的优先级顺序先后执行

2.自定义拒绝策略

拒绝策略:

AbortPolicy :抛出异常

DiscardPolicy: 丢弃新提交的任务

DiscardOldestPolicy:丢弃最先提交并未处理的任务,也就是将要处理的那个

CallerRunsPolicy:只要线程未关闭,将处理被丢弃的任务

import java.util.concurrent.*;

/**
 * 拒绝策略接口   rejectedExecutionHandler
 */
public class TestQueue {

    private static class DemoThread implements Runnable{

        private String name;
        public DemoThread(String name){
            this.name = name;
        }
        @Override
        public void run(){

            System.out.println(Thread.currentThread().getId() + "   " + name + "开始执行..");
        }
    }

    /**
     * 核心线程5个  最大线程5个   任务队列可以存放3个
     * @param args
     */
    public static void main(String[] args){
        ExecutorService executorService = new ThreadPoolExecutor(5, 5, 0, TimeUnit.MILLISECONDS,
                new LinkedBlockingQueue<Runnable>(3), new RejectedExecutionHandler() {
            @Override
            public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
                System.out.println(r.toString() + " is discarded");
            }
        });

        for(int i = 0; i < 10; i++){
            executorService.submit(new DemoThread("t"+i));
        }
        executorService.shutdown();
    }
}

结果显示:

11 t0开始执行..
13 t2开始执行..
14 t3开始执行..
java.util.concurrent.FutureTask@49476842 is discarded
java.util.concurrent.FutureTask@78308db1 is discarded
11 t5开始执行..
14 t6开始执行..
13 t7开始执行..
15 t4开始执行..
12 t1开始执行..

3.自定义线程创建

import java.util.concurrent.*;

public class TestThreadFactory {

    private static class DemoThread implements Runnable{

        private String name;
        public DemoThread(String name){
            this.name = name;
        }
        @Override
        public void run(){
            System.out.println(name + " is starting...");
        }
    }

    public static void main(String[] args){
        ExecutorService executorService = new ThreadPoolExecutor(5, 5, 0, TimeUnit.MILLISECONDS,
                new LinkedBlockingQueue<Runnable>(), new ThreadFactory() {
            @Override
            public Thread newThread(Runnable r) {
               Thread t = new Thread(r);
               t.setDaemon(true);  //将线程设为守护线程
                System.out.println(t + "   created");
                return t;
            }
        });

        for(int i = 0; i < 10; i++){
            executorService.submit(new DemoThread("t" + i));
        }
        executorService.shutdown();
    }
}
结果显示:

Thread[Thread-0,5,main] created
Thread[Thread-1,5,main] created
Thread[Thread-2,5,main] created
Thread[Thread-3,5,main] created
Thread[Thread-4,5,main] created
t0 is starting...
t5 is starting...
t6 is starting...
t7 is starting...
t8 is starting...
t9 is starting...
t1 is starting...
t3 is starting...
t4 is starting...

5个核心线程被创建,10个任务被处理

4.扩展线程池

import java.util.concurrent.ExecutorService;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class TestThreadPoolExecutor {

    private static class DemoThread implements Runnable{

        @Override
        public void run(){
            System.out.println(Thread.currentThread().getName());
        }
    }

    public static void main(String[] args){
        ExecutorService executorService = new ThreadPoolExecutor(5, 5, 0, TimeUnit.MILLISECONDS,
                new LinkedBlockingQueue()){
            @Override
            public void beforeExecute(Thread t, Runnable r){
                System.out.println(t.getName() + "创建前...");
            }

            @Override
            public void afterExecute(Runnable r, Throwable t){
                System.out.println(r.toString() + "创建后...");
            }

            @Override
            public void terminated(){
                System.out.println("线程池退出...");
            }
        };

        for(int i = 0; i < 5; i++){
            executorService.submit(new DemoThread());
        }

        executorService.shutdown();
    }
}

结果显示:

pool-1-thread-1创建前...
pool-1-thread-1
pool-1-thread-2创建前...
pool-1-thread-2
java.util.concurrent.FutureTask@c10f5b9创建后...
pool-1-thread-4创建前...
pool-1-thread-4
java.util.concurrent.FutureTask@227b738c创建后...
pool-1-thread-5创建前...
pool-1-thread-5
java.util.concurrent.FutureTask@34338849创建后...
pool-1-thread-3创建前...
pool-1-thread-3
java.util.concurrent.FutureTask@79274273创建后...
java.util.concurrent.FutureTask@286f5312创建后...
线程池退出...