Java并发编程学习系列四:线程池

概念

为什么要使用多线程呢?

先从总体上来说:

  • 从计算机底层来说:线程可以比作是轻量级的进程,是程序执行的最小单位,线程间的切换和调度的成本远远小于进程。另外,多核 CPU 时代意味着多个线程可以同时运行,这减少了线程上下文切换的开销。
  • 从当代互联网发展趋势来说:现在的系统动不动就要求百万级甚至千万级的并发量,而多线程并发编程正是开发高并发系统的基础,利用好多线程机制可以大大提高系统整体的并发能力以及性能。

再深入到计算机底层来探讨:

  • 单核时代: 在单核时代多线程主要是为了提高 CPU 和 IO 设备的综合利用率。举个例子:当只有一个线程的时候会导致 CPU 计算时,IO 设备空闲;进行 IO 操作时,CPU 空闲。我们可以简单地说这两者的利用率目前都是 50%左右。但是当有两个线程的时候就不一样了,当一个线程执行 CPU 计算时,另外一个线程可以进行 IO 操作,这样两个的利用率就可以在理想情况下达到 100%了。
  • 多核时代: 多核时代多线程主要是为了提高 CPU 利用率。举个例子:假如我们要计算一个复杂的任务,我们只用一个线程的话,CPU 只会一个 CPU 核心被利用到,而创建多个线程就可以让多个 CPU 核心被利用到,这样就提高了 CPU 的利用率。

使用多线程可能带来什么问题?

并发编程的目的就是为了能提高程序的执行效率,进而提高程序运行速度,但是并发编程并不总是能提高程序运行速度的,而且并发编程可能会遇到很多问题,比如: 内存泄漏、上下文切换、死还有受限于硬件和软件的资源闲置问题

线程池

池化技术

程序的运行,其本质上,是对系统资源(CPU、内存、磁盘、网络等等)的使用。如何高效的使用这些资源是我们编程优化演进的一个方向。今天说的线程池就是一种对CPU利用的优化手段。

通过学习线程池原理,明白所有池化技术的基本设计思路。遇到其他相似问题可以解决。

池化技术

前面提到一个名词——池化技术,那么到底什么是池化技术呢 ?

池化技术简单点来说,就是提前保存大量的资源,以备不时之需。在机器资源有限的情况下,使用池化技术可以大大的提高资源的利用率,提升性能等。

在编程领域,比较典型的池化技术有: 线程池、连接池、内存池、对象池等。

主要来介绍一下其中比较简单的线程池的实现原理,通过对线程池的理解,学习并掌握所有编程中池化技术的底层原理。

线程池

线程池的原理很简单,类似于操作系统中的缓冲区的概念,它的流程:先启动若干数量的线程,并让这些线程都处于睡眠状态,当客户端有一个新请求时,就会唤醒线程池中的某一个睡眠线程,让它来处理客户端的这个请求,当处理完这个请求后,线程又置于睡眠状态,而不是销毁。

Java中线程池的实现

Java 中的线程池是通过 Executor 框架实现的,该框架中用到了 Executor ,Executors,ExecutorServiceThreadPoolExecutor 这几个类。

Java并发编程学习系列四:线程池

Executors三大方法

Executors.newSingleThreadExecutor()

只有一个线程

public class PoolDemo01 {

    public static void main(String[] args) {
        ExecutorService executorService = Executors.newSingleThreadExecutor();//有且仅有一个固定的线程

        try {
            for (int i = 0; i < 10; i++) {
                executorService.execute(()->{
                    System.out.println(Thread.currentThread().getName());
                });
            }
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            executorService.shutdown();
        }
    }
}
复制代码

执行结果为:

pool-1-thread-1
pool-1-thread-1
pool-1-thread-1
pool-1-thread-1
pool-1-thread-1
pool-1-thread-1
pool-1-thread-1
pool-1-thread-1
pool-1-thread-1
pool-1-thread-1
复制代码

从结果可以看出只有一个线程。

Executors.newFixedThreadPool(int)

执行长期任务性能好,创建一个线程池,一池有N个固定的线程,有固定线程数的线程。

public class PoolDemo01 {

    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(5);//创建指定个数的线程

        try {
            for (int i = 0; i < 10; i++) {
                executorService.execute(()->{
                    System.out.println(Thread.currentThread().getName());
                });
            }
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            executorService.shutdown();
        }
    }
}
复制代码

执行结果为:

pool-1-thread-2
pool-1-thread-2
pool-1-thread-3
pool-1-thread-1
pool-1-thread-1
pool-1-thread-1
pool-1-thread-4
pool-1-thread-3
pool-1-thread-2
pool-1-thread-5
复制代码

从结果可以看出,最高有5个线程在执行。

Executors.newCachedThreadPool()

执行很多短期异步任务,线程池根据需要创建新线程,但在先构建的线程可用时将重用他们。 可扩容,遇强则强。

public class PoolDemo01 {

    public static void main(String[] args) {
        ExecutorService executorService = Executors.newCachedThreadPool();//该线程池可扩容,遇强则强

        try {
            for (int i = 0; i < 100; i++) {
                executorService.execute(()->{
                    System.out.println(Thread.currentThread().getName());
                });
            }
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            executorService.shutdown();
        }
    }
}
复制代码

在本机上最高有 41个线程在执行。

ThreadPoolExecutor七大参数

通过查看上述三大方法的源码,可以发现都是 new 了一个 ThreadPoolExecutor 对象,只是传入的参数有所不同,关于 ThreadPoolExecutor 的构造方法定义如下:

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.corePoolSize = corePoolSize;
    this.maximumPoolSize = maximumPoolSize;
    this.workQueue = workQueue;
    this.keepAliveTime = unit.toNanos(keepAliveTime);
    this.threadFactory = threadFactory;
    this.handler = handler;
}
复制代码

参数理解:

  • corePoolSize: 核心线程数 。在创建了线程池后,线程中没有任何线程,等到有任务到来时才创建线程去执行任务。默认情况下,在创建了线程池后,线程池中的线程数为0,当有任务来之后,就会创建 一个线程去执行任务,当线程池中的线程数目达到corePoolSize后,就会把到达的任务放到缓存队列当中。
  • maximumPoolSize: 最大线程数 。表明线程中最多能够创建的线程数量,此值必须大于等于1。
  • keepAliveTime: 空闲的线程保留的时间
  • unit: 空闲线程的保留时间单位
  • BlockingQueue: 阻塞队列 ,存储等待执行的任务。参数有ArrayBlockingQueue、LinkedBlockingQueue、SynchronousQueue可选。
  • ThreadFactory: 线程工厂 ,用来创建线程,一般默认即可
  • RejectedExecutionHandler:队列已满,而且任务量大于最大线程的 异常处理策略 。有以下取值
ThreadPoolExecutor.AbortPolicy    //丢弃任务并抛出RejectedExecutionException异常
ThreadPoolExecutor.CallerRunsPolicy    //由调用线程处理该任务
ThreadPoolExecutor.DiscardOldestPolicy    //丢弃队列最前面的任务,然后重新尝试执行任务
ThreadPoolExecutor.DiscardPolicy    //也是丢弃任务,但是不抛出异常。
复制代码

ThreadPoolExecutor底层原理

Java并发编程学习系列四:线程池

我们用个案例来进行解析银行办理业务。比如说目前银行只有两个工作窗口对外开放,有三个空闲位置允许等待,当一下子来了5个人,其中两个人去办理业务,另外三个人去等待。如果人数大于5,则临时开放另外三个工作窗口来处理业务办理。那么该银行最多一次可以接收8个人,其中5个人办理业务,另外3个人等候。

流程图如下:

Java并发编程学习系列四:线程池
  1. 在创建了线程池后,开始等待请求。

  2. 当调用 execute()方法添加一个请求任务时,线程池会做出如下判断:

  3. 如果正在运行的线程数量小于 corePoolSize,那么马上创建线程运行这个任务:

  4. 如果正在运行的线程数量大于或等于 corePoolSize,那么将这个任务放入队列:

  5. 如果这个时候队列满了且正在运行的线程数量还小于 maximumPoolSize,那么还是要创建非核心线程立刻运行这个任务;

  6. 如果队列满了且正在运行的线程数量大 maximumPoolSize,那么线程池会启动饱和拒绝策略来执行。

  7. 当一个线程完成任务时,它会从队列中取下一个任务来执行。

  8. 当一个线程无事可做超过一定的时间(keepA1iveTime)时,线程会判断:

  • 如果当前运行的线程数大于 corePoolSize ,那么这个线程就被停掉。
  • 所以线程池的所有任务完成后,它最终会收缩到 corePoolSize 的大小。

代码实现为:

public class PoolDemo02 {

    static final int NUM = 8;
    public static void main(String[] args) {
        ExecutorService executorService = new ThreadPoolExecutor(2, 5, 3, TimeUnit.SECONDS, new LinkedBlockingDeque<>(3),
                Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.AbortPolicy());//该拒绝策略会抛出异常信息

        try {
            //最大承载:Deque+max=3+5
            for (int i = 1; i <= NUM; i++) {
                executorService.execute(() -> {
                    System.out.println(Thread.currentThread().getName());
                });
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            executorService.shutdown();
        }
    }
}
复制代码

当 NUM 值不大于5时,执行结果为:

pool-1-thread-2
pool-1-thread-1
pool-1-thread-2
pool-1-thread-1
pool-1-thread-2
复制代码

当 NUM 值大于5,不大于8时,执行结果为:

pool-1-thread-1
pool-1-thread-2
pool-1-thread-1
pool-1-thread-2
pool-1-thread-3
pool-1-thread-1
pool-1-thread-4
pool-1-thread-5
复制代码

当 NUM 值大于8时,执行会报错,错误信息如下:

java.util.concurrent.RejectedExecutionException
复制代码

如何设置参数

我们在上面的学习中使用 Executors 来创建线程池,但是实际工作中我们并不会这样做,需要自定义来创建线程池,如阿里巴巴开发手册中所提到的:

Java并发编程学习系列四:线程池

虽然建议创建线程池不要使用 Executors,但是与它关联很紧密,我们入门阶段还是要从它下手。

线程池是否越大越好?

一个计算为主的程序(专业一点称为 CPU密集型程序 )。多线程跑的时候,可以充分利用起所有的cpu 核心,比如说4个核心的 cpu,开4个线程的时候,可以同时跑4个线程的运算任务,此时是最大效率。

但是如果线程远远超出 cpu 核心数量,反而会使得任务效率下降,因为频繁的切换线程也是要消耗时间的。因此对于 cpu 密集型的任务来说, 线程数等于cpu数 是最好的了。

如果是一个磁盘或网络为主的程序( IO密集型 )。一个线程处在IO等待的时候,另一个线程还可以在CPU里面跑,有时候CPU闲着没事干,所有的线程都在等着IO,这时候他们就是同时的了,而单线程的话此时还是在一个一个等待的。我们都知道IO的速度比起CPU来是慢到令人发指的。所以开多线程,比方说多线程网络传输,多线程往不同的目录写文件,等等。

此时 线程数等于 IO任务数 是最佳的。

原文 

https://juejin.im/post/5f01d4a46fb9a07e5f5178de

本站部分文章源于互联网,本着传播知识、有益学习和研究的目的进行的转载,为网友免费提供。如有著作权人或出版方提出异议,本站将立即删除。如果您对文章转载有任何疑问请告之我们,以便我们及时纠正。

PS:推荐一个微信公众号: askHarries 或者qq群:474807195,里面会分享一些资深架构师录制的视频录像:有Spring,MyBatis,Netty源码分析,高并发、高性能、分布式、微服务架构的原理,JVM性能优化这些成为架构师必备的知识体系。还能领取免费的学习资源,目前受益良多

转载请注明原文出处:Harries Blog™ » Java并发编程学习系列四:线程池

赞 (0)
分享到:更多 ()

评论 0

  • 昵称 (必填)
  • 邮箱 (必填)
  • 网址