Java 并发编程(线程池)(5)

最新推荐文章于 2024-08-17 10:17:43 发布

面向c v编程

最新推荐文章于 2024-08-17 10:17:43 发布

阅读量98

点赞数

分类专栏：笔记 java并发编程文章标签： java 开发语言经验分享

本文链接：https://blog.csdn.net/m0_49797779/article/details/124705252

版权

笔记同时被 2 个专栏收录

52 篇文章 0 订阅

订阅专栏

java并发编程

6 篇文章 0 订阅

订阅专栏

线程池

概述:

数据库链接池: 每次与数据链接, 创建连接对象Connection 操作完之后,进行销毁频繁创建销毁比较耗时.创建一个池子,预先在池子中初始化好一部分连接(Connection )对象, 使用时直接获取即可,用完还回,不需要频繁创建销毁.

线程池和数据库连接池的思想是一样的:

以前我们需要使用线程的时候就去创建一个线程，这样实现起来非常简便，但是就会有一个问题：如果并发的线程数量很多，并且每个线程都是执行一个时间很短的任务就结束了，这样频繁创建线程就会大大降低系统的效率，因为频繁创建线程和销毁线程需要时间。那么有没有一种办法使得线程可以复用，就是执行完一个任务，并不被销毁，而是可以继续执行其他的任务？

Java 中可以通过线程池来达到这样的效果。线程池里的每一个线程代码结束后，并不会死亡，而是再次回到线程池中成为空闲状态，等待下一个对象来使用。

为什么使用线程池?

并发量大的情况下,频发创建销毁线程开销较大.创建线程池缓解压力.

jdk5之后,提供ThreadPoolExecutor类来实现线程池创建, 是建议被使用的(见《阿里巴巴 java 开发规范》), 里面有7个参数来设置对线程池的特征的定义.

在这里插入图片描述

ThreadPoolExecutor 类:

java.uitl.concurrent.ThreadPoolExecutor 类是线程池中最核心的一个类.

ThreadPoolExecutor 继承了 AbstractExecutorService 类，并提供了四个构造器，事实上，通过观察每个构造器的源码具体实现，发现前面三个构造器都是调用的第四个构造器进行的初始化工作。

public class ThreadPoolExecutor extends AbstractExecutorService {
    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;
    }
}