线程池的原理

perseveregz

已于 2023-08-09 18:05:23 修改

阅读量171

点赞数

分类专栏： Java日常学习多线程文章标签： java 开发语言

于 2023-08-02 21:41:23 首次发布

本文链接：https://blog.csdn.net/ggggggzzzzz/article/details/132070726

版权

Java日常学习同时被 2 个专栏收录

51 篇文章 4 订阅

订阅专栏

多线程

4 篇文章 0 订阅

订阅专栏

1.创建线程池

1.第一种方式：ThreadPoolExecutor类

1.ThreadPoolExecutor类的源码

2.ThreadPoolExecutor类的源码的参数

2.1 int corePoolSize：

2.2 int maximumPoolSize：

2.3 long keepAliveTime：

2.4 TimeUnit unit：存活时间单位：

2.5 BlockingQueue workQueue：

2.6 ThreadFactory threadFactory：

2.7 RejectedExecutionHandler handler：

2.1 newFixedThreadPool(int nThreads)：创建固定线程池

2.2 newSingleThreadExecutor()：创建单线程

2.3 newCachedThreadPool()：创建可缓存线程池

2.4 newScheduledThreadPool(int corePoolSize)：创建定时执行线程池

3.创建线程池方法的选择

1.任务队列的分类

2. Executors工具类的方法中使用的任务队列

2.线程池执行过程

1.创建线程池

1.第一种方式：ThreadPoolExecutor类

1.ThreadPoolExecutor类的源码

概念：是线程池的实现类，使用类的构造器来创建线程

源码：

public ThreadPoolExecutor(
							  //核心线程数
			                  int corePoolSize,
							  //最大线程数
							  int maximumPoolSize,
							  //线程存活时间
							  long keepAliveTime,
							  //存活时间单位：通常是Seconds
							  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;
	}

2.ThreadPoolExecutor类的源码的参数

2.1 int corePoolSize：

核心线程数，代表了处理线程时的核心运行线程数量（任务队列此时是没有存满的）

2.2 int maximumPoolSize：

最大线程数，当任务队列存满了，同时运行的线程数量大于核心线程数，此时代表的是最大线程数量

这二者的区别：一般任务队列没存满，就用corePoolSize；任务队列存满后仍有线程任务，此时就需要用到maximumPoolSize，创建非核心线程处理任务

2.3 long keepAliveTime：

线程存活时间，线程未处理任务的最大存活时间，超过这个时间就回收线程

2.4 TimeUnit unit：存活时间单位：

通常是keepAliveTime的单位，比如TimeUnit.Seconds

2.5 BlockingQueue<Runnable> workQueue：

任务队列，当运行线程的数量达到corePoolSize，则将任务存放在任务队列中

2.6 ThreadFactory threadFactory：

线程工厂，用来创建新线程

2.7 RejectedExecutionHandler handler：

拒绝策略，当任务队列workQueue已满，且正在运行的线程数达到了最大线程数maximumPoolSize，此时需要对新任务根据策略进行处理；

常用的拒绝策略：

2.7.1 AbortPolicy：中止策略；直接抛出异常

2.7.2 DiscardPolicy：丢弃策略；将新任务丢弃

2.7.3 DiscardOldestPolicy：丢弃最旧策略；丢弃最旧的任务请求

2.7.4 CallerRunsPolicy：调用方运行策略；调用当前线程运行新任务

2.第二种方式：Executors工具类

1.Executors工具类的源码

概念：是一个工具类，定义了许多创建线程池的方法

源码：Executors工具类中声明的方法有：

    public static ExecutorService newFixedThreadPool(int nThreads) {
        return new ThreadPoolExecutor(nThreads, nThreads,
                                      0L, TimeUnit.MILLISECONDS,
                                      new LinkedBlockingQueue<Runnable>());
    }


    public static ExecutorService newSingleThreadExecutor() {
        return new FinalizableDelegatedExecutorService
            (new ThreadPoolExecutor(1, 1,
                                    0L, TimeUnit.MILLISECONDS,
                                    new LinkedBlockingQueue<Runnable>()));
    }

    public static ExecutorService newCachedThreadPool() {
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                      60L, TimeUnit.SECONDS,
                                      new SynchronousQueue<Runnable>());
    }

    public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
        return new ScheduledThreadPoolExecutor(corePoolSize);
    }