[java并发]java高并发系列 - 第18天：JAVA线程池，这一篇就够了

最新推荐文章于 2024-09-25 10:59:43 发布
最新推荐文章于 2024-09-25 10:59:43 发布
阅读量327 收藏
点赞数
分类专栏： Java # Java并发 文章标签： 队列 java 多线程 负载均衡 运维
原文链接：https://mp.weixin.qq.com/s/Tps4vF8FduQsWzYOxLz4YQ
版权

原文链接：查看原文

感谢公众号“ 路人甲Java”的分享，如有冒犯，请联系删除，快去关注他吧
在这里插入图片描述

本文主要内容

  1. 什么是线程池
  2. 线程池实现原理
  3. 线程池中常见的各种队列
  4. 自定义线程创建的工厂
  5. 常见的饱和策略
  6. 自定义饱和策略
  7. 线程池中两种关闭方法有何不同
  8. 扩展线程池
  9. 合理地配置线程池
  10. 线程池中线程数量的配置

什么是线程池？

大家用jdbc操作过数据库应该知道，操作数据库需要和数据库建立连接，拿到连接之后才能操作数据库，用完之后销毁。数据库连接的创建和销毁其实是比较耗时的，真正和业务相关的操作耗时是比较短的。每个数据库操作之前都要创建连接，为了提升系统性能，后来出现了数据库连接池，系统启动的时候，先创建很多连接放在池子链，使用的时候，直接从连接池中获取一个，使用完毕后返回到池子里面，继续给其他需要者使用，这其中就省去创建连接的时间，从而提升了系统整体的性能。

线程池和数据库连接池的原理差不多，创建线程去处理业务，可能创建线程的时间比处理业务的时间还长一些，如果系统能够提前为我们创建好线程，我们需要的时候直接拿来使用，用完之后不是直接将其关闭，而是将其返回到线程池中，给其他需要者使用，这样直接节省了创建和销毁的时间，提升了系统 的性能。

简单地说，在使用了线程池之后，创建线程变成了从线程池中获取一个空闲的线程，然后使用，关闭线程变成了将线程归还到线程池。

线程池实现原理

当向线程池提交一个任务之后，线程池的处理流程如下：

  1. 判断是否达到核心线程数，若未达到，则直接创建新的线程处理当前传入的任务，是否进入下个流程
  2. 线程池中的工作队列是否已满，若未满，则将任务丢入工作队列中先存着等待处理，否则进入下一个流程
  3. 是否达到最大线程数，若未达到，则创建新的线程处理当前传入的任务，否则交给线程池中的饱和和策略进行处理。

流程图如下：

在这里插入图片描述

举个例子，加深理解：

咱们作为开发者，上面都有开发主管，主管下面带领几个小弟干活，CTO给主管授权说，你可以招聘5个小弟干活，新来任务，如果小弟还不到5个，立即去招聘一个来干这个新来的任务，当5个小弟都招来了，再来任务之后，将任务记录到一个表格中，表格中最多记录100个，小弟们会主动去表格中获取任务执行，如果5个小弟都在干活，并且表格中也记录满了，那你可以将小弟扩充到20个，如果20个小弟都在干活，并且存放任务的表也满了，产品经理再来任务后，是直接拒绝，还是让产品自己干，这个由你自己决定，小弟们都尽心尽力干活，任务都处理完了，突然公司业绩下滑，几个员工没事儿干，打酱油，为了节约成本，CTO主管把小弟控制到5人，其他15人直接被干掉了，所以作为小弟们，别让自己闲着，多干活。

原理： 先找几个人干活，大家都忙于干活，任务太多可以排期，排期的任务太多了，再招一些人来干活，最后干活和排期都达到上层领导要求的上限了，那需要采取一些其他策略进行处理了。对于长时间不干活的人，考虑将其开掉，节约资源和成本。

java中的线程池

jdk提供了线程池的具体实现，实现类是：java.util.cocurrent.ThreadPoolExecutor，主要构造方法：

public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory,
                              RejectedExecutionHandler handler)
  • corePoolSize：核心线程大小，当提交一个任务到线程池时，线程池会创建一个任务来执行任务，即使有其他空闲线程可以处理任务也会创建新线程，等到工作的线程数大于核心线程数时就不会再创建了。如果调用了线程池的prestartAllCoreThreads方法，线程池会提前把核心线程都创建好，并启动
  • maximumPoolSize：线程池允许创建的最大线程数。如果队列满了，并且已创建的线程数小于最大线程数，则线程池会再创建新的线程执行任务。如果我们使用了无界队列，那么所有的任务会加入队列，这个参数就没有什么效果了。
  • keepAliveTime：线程池的工作线程空闲后，保持存活的时间。如果没有任务处理了，有些线程会空闲，空闲的时间超过了这个值，会被回收掉。如果任务很多，并且每个任务的执行时间比较短，避免线程重复创建和回收，可以调大这个时间，提高线程的利用率。
  • unit：keepAliveTime的时间单位，可以选择的单位有天、小时、分钟、毫秒、微秒、千分之一毫秒和纳秒。类型是一个枚举java.util.cocurrent.TimeUnit，这个枚举也经常使用，可以通过源码了解
  • workQueue：工作队列，用于缓存待处理任务的阻塞队列，常见的有4种，本文后面会介绍
  • threadFactory：线程池中创建线程的工厂，可以通过线程工厂给每个创建出来的线程设置更有意义的名字
  • handler：饱和策略，当线程池无法处理新来的任务时，那么需要提供一种策略处理提交的新任务，默认有4种策略，本文后续会有说明

调用线程池的execute方法处理任务，执行execute方法的过程：

  1. 判断线程池中运行的线程数是或否小于corepoolsize，是：则创建新的线程来处理任务，否：执行下一步
  2. 试图将任务添加到workQueue指定的队列中，如果无法添加到队列，进入下一步
  3. 判断线程池中运行的线城市是否小于maximumPoolSize，是：则新增线程处理当前传入的任务，否：将任务传递给handler对象rejectedExecution方法处理

线程池的使用步骤：

  1. 调用构造方法创建线程池
  2. 调用线程池的方法处理任务
  3. 关闭线程池

线程池使用的简单示例

上一个简单的示例，如下：

package aboutThread.Concurrent.Day18;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;



public class Demo1 {
    static ThreadPoolExecutor executor = new ThreadPoolExecutor(3,
     5,
     10,
    TimeUnit.SECONDS,
    new ArrayBlockingQueue<Runnable>(10),
    Executors.defaultThreadFactory(),
    new ThreadPoolExecutor.AbortPolicy());

    public static void main(String[] args){
        for (int i = 0; i < 10; i++) {
            int j = i;
            String taskName = "任务" + j;
            executor.execute(() ->{
                //模拟任务内部处理耗时
                try {
                    TimeUnit.SECONDS.sleep(j);
                } catch (InterruptedException e) {
                     e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + taskName + "处理完毕！");
            });
        }
        //关闭线程池
        executor.shutdown();
    }
}

输出：

pool-1-thread-1任务0处理完毕！
pool-1-thread-2任务1处理完毕！
pool-1-thread-3任务2处理完毕！
pool-1-thread-1任务3处理完毕！
pool-1-thread-2任务4处理完毕！
pool-1-thread-3任务5处理完毕！
pool-1-thread-1任务6处理完毕！
pool-1-thread-2任务7处理完毕！
pool-1-thread-3任务8处理完毕！
pool-1-thread-1任务9处理完毕！

线程池中常见的5种队列

任务太多的时候，工作队列用于暂时缓存待处理的任务，jdk中常见的5中阻塞队列：

  • ArrayBlockigQueue: 是一个基于数组结构的有界阻塞队列，此队列按照先进先出原则对元素进行排序
  • LinkedBlockingQueue: 是一个基于链表结构的阻塞队列，此队列按照先进先出排序元素，吞吐量通常要高于ArrayBlockQueue。静态工厂方法Executors.newFixedThreadPool 使用了这个方法。
  • SynchronousQueue: 一个不存储元素的阻塞队列，每个插入操作必须等到另外一个线程调用移除操作，否则插入操作一直处理阻塞状态，吞吐量通常要高于LinkedBlockingQueue，静态工厂方法Executors.newCachedThreadPool 使用了这个队列
  • PriorityBlockingQueue: 优先级队列，进入队列的元素按照优先级会进行排序

下面主要对后两种队列的使用进行示例说明：

SyncrhonousQueue队列的线程池

package aboutThread.Concurrent.Day18;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

public class Demo2 {
    public static void main(String[] args){
        ExecutorService executor = Executors.newCachedThreadPool();
        for (int i = 0; i < 50; i++) {
            int j = i;
            String taskName = "任务" + j;
            executor.execute(() -> {
                System.out.println(Thread.currentThread().getName() + "处理" + taskName);
                //模拟任务内部处理耗时
               try {
                   TimeUnit.SECONDS.sleep(1);
               } catch (InterruptedException e) {
                    e.printStackTrace();
               }
            });
        }
        executor.shutdown();
    }
}

输出：

pool-1-thread-1任务0处理完毕！
pool-1-thread-2任务1处理完毕！
pool-1-thread-3任务2处理完毕！
pool-1-thread-1任务3处理完毕！
pool-1-thread-2任务4处理完毕！
pool-1-thread-3任务5处理完毕！
pool-1-thread-1任务6处理完毕！
pool-1-thread-2任务7处理完毕！
pool-1-thread-3任务8处理完毕！
pool-1-thread-1任务9处理完毕！
{20-06-03 10:08}Arans-Mac:~/JavaPrjs_VS_CODE/JavaThread@master✗✗✗✗✗✗ aran%  cd /Users/aran/JavaPrjs_VS_CODE/JavaThread ; /Library/Java/JavaVirtualMachines/jdk-13.jdk/Contents/Home/bin/java -Dfile.encoding=UTF-8 -cp "/Users/aran/Library/Application Support/Code/User/workspaceStorage/0f284770f0218fea9250fa3f3328bca2/redhat.java/jdt_ws/JavaThread_f39215e3/bin" aboutThread.Concurrent.Day18.Demo2 
pool-1-thread-2处理任务1
pool-1-thread-4处理任务3
pool-1-thread-3处理任务2
pool-1-thread-1处理任务0
pool-1-thread-5处理任务4
pool-1-thread-6处理任务5
pool-1-thread-7处理任务6
pool-1-thread-8处理任务7
pool-1-thread-9处理任务8
pool-1-thread-10处理任务9
pool-1-thread-11处理任务10
pool-1-thread-12处理任务11
pool-1-thread-13处理任务12
pool-1-thread-14处理任务13
pool-1-thread-15处理任务14
pool-1-thread-16处理任务15
pool-1-thread-17处理任务16
pool-1-thread-18处理任务17
pool-1-thread-19处理任务18
pool-1-thread-20处理任务19
pool-1-thread-21处理任务20
pool-1-thread-22处理任务21
pool-1-thread-23处理任务22
pool-1-thread-24处理任务23
pool-1-thread-25处理任务24
pool-1-thread-26处理任务25
pool-1-thread-27处理任务26
pool-1-thread-28处理任务27
pool-1-thread-29处理任务28
pool-1-thread-30处理任务29
pool-1-thread-31处理任务30
pool-1-thread-32处理任务31
pool-1-thread-33处理任务32
pool-1-thread-34处理任务33
pool-1-thread-35处理任务34
pool-1-thread-36处理任务35
pool-1-thread-37处理任务36
pool-1-thread-38处理任务37
pool-1-thread-39处理任务38
pool-1-thread-40处理任务39
pool-1-thread-41处理任务40
pool-1-thread-42处理任务41
pool-1-thread-43处理任务42
pool-1-thread-44处理任务43
pool-1-thread-45处理任务44
pool-1-thread-46处理任务45
pool-1-thread-47处理任务46
pool-1-thread-48处理任务47
pool-1-thread-49处理任务48
pool-1-thread-50处理任务49

代码中使用Executors.newCachedThreadPool()创建线程池，看一下源码：

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

从输出中可以看出，系统创建了50个线程处理任务，代码中使用了SynchornousQueue 同步队列，这种队列比较特殊，放入元素必须要另外一个线程去获取这个元素，否则放入元素会失败或者一直阻塞在那里，直到有线程取走，示例中任务处理休眠了指定的时间，导致已创建的工作线程都忙于处理任务，所以新来任务之后，将任务丢入同步队列会失败，丢入队列失败之后，会尝试新建线程处理任务，使用上面的方式创建线程池需要注意，如果需要处理的任务比较耗时，会导致新来的任务都会创建新的线程进行处理，可能会导致创建非常多的线程，最终耗尽系统资源，触发OOM(Out of Memory，内存溢出)。

PriorityBlockingQueue优先级队列的线程池

package aboutThread.Concurrent.Day18;

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

public class Demo3 {
    static class Task implements Runnable,Comparable<Task>{

        private int i;
        private String name;

        public Task(int i,String name){
            this.i = i;
            this.name = name;
        }

        @Override
        public int compareTo(Task o) {
            return Integer.compare(o.i, this.i);
        }

        @Override
        public void run() {
             System.out.println(Thread.currentThread().getName() + "处理" + this.name);
        }
        
    }

    public static void main(String[] args){
        ExecutorService executor = new ThreadPoolExecutor(1,
         1,
         60L,
          TimeUnit.SECONDS,
          new PriorityBlockingQueue<>());
          for (int i = 0; i < 10; i++) {
              String taskName = "任务" + i;
              executor.execute(new Task(i,taskName));
          }
          for (int i = 100; i >= 90; i--) {
              String taskName = "任务" + i;
              executor.execute(new Task(i,taskName));
          }
          executor.shutdown();
    }
}

输出：

pool-1-thread-1处理任务0
pool-1-thread-1处理任务100
pool-1-thread-1处理任务99
pool-1-thread-1处理任务98
pool-1-thread-1处理任务97
pool-1-thread-1处理任务96
pool-1-thread-1处理任务95
pool-1-thread-1处理任务94
pool-1-thread-1处理任务93
pool-1-thread-1处理任务92
pool-1-thread-1处理任务91
pool-1-thread-1处理任务90
pool-1-thread-1处理任务9
pool-1-thread-1处理任务8
pool-1-thread-1处理任务7
pool-1-thread-1处理任务6
pool-1-thread-1处理任务5
pool-1-thread-1处理任务4
pool-1-thread-1处理任务3
pool-1-thread-1处理任务2
pool-1-thread-1处理任务1

输出中，除了第一个任务，其他任务按照优先级高低按顺序处理。原因在于：创建线程池的时候使用了优先级队列，进入队列中的任务会进行排序，任务的先后顺序由Task中的 i 变量决定。向PriorityBlockingQueue加入元素的时候，内部会调用代码中的Task的compareTo方法决定元素的先后顺序。

自定义创建线程的工厂

给线程池中线程起一个有意义的名字，在系统出现问题的时候，通过线程堆栈信息可以更容易发现系统中问题所在。自定义创建工厂需要实现 java.util.concurren.ThreadFactory 接口中的Thread new Thread(Runnable r) 方法，参数为传入的任务，需要返回一个工作线程。

示例代码：

package aboutThread.Concurrent.Day18;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;

 

public class Demo4 {
    static AtomicInteger threadNum = new AtomicInteger(1);

    public static void main(String[] args){
        ThreadPoolExecutor executor = new ThreadPoolExecutor(5,
        5,
        60L,
        TimeUnit.SECONDS,
        new ArrayBlockingQueue<Runnable>(10),r ->{
            Thread thread = new Thread(r);
            thread.setName("自定义线程-" + threadNum.getAndIncrement());
            return thread;
        });

        for (int i = 0; i < 5; i++) {
            String taskName = "任务-" + i;
            executor.execute(() -> {
                System.out.println(Thread.currentThread().getName() + "处理" + taskName);
            }); 
        }
        executor.shutdown();
    }
}

输出：

自定义线程-1处理任务-0
自定义线程-3处理任务-2
自定义线程-2处理任务-1
自定义线程-4处理任务-3
自定义线程-5处理任务-4

代码中在任务中输出了当前线程的名称，可以看到我们自定义的名称。

通过jstack 查看线程的堆栈信息，也可以看到我们自定义的名称，我们可以将代码中executor.shutdown();先给注释掉让程序先不退出，然后通过jstack查看，如下：

在这里插入图片描述

4种饱和策略

当线程池中队列已满，并且线程池已达到最大线程数，线程池会将任务传递给饱和策略进行处理。这些策略都实现了RejectedExecutionHandler接口。接口中有个方法：

void rejectedExecution(Runnable r,ThreadPoolExecutor executor)

参数说明：
r：需要执行的任务
executor：当前线程池对象

JDK中提供了4种常见的饱和策略

  • AbortPolicy : 直接抛出异常
  • CallerRunsPolicy : 在当前调用者的线程中运行任务，即随丢来的任务，由他自己去处理
  • DiscardOldestPolicy: 丢弃队列中最老的一个任务，即丢弃队列头部的一个任务，然后执行当前传入的任务
  • DiscardPolicy : 不处理，直接丢弃掉，方法内部为空

自定义饱和策略

需要实现RejectedExecutionHandler接口。任务无法处理时，我们想记录下日志，我们需要定义一个饱和策略，示例代码：

package aboutThread.Concurrent.Day18;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;



public class Demo5 {
    static class Task implements Runnable{
        String name;

        public Task(String name){
            this.name = name;
        }

        @Override
        public void run(){
            System.out.println(Thread.currentThread().getName() + "处理" + this.name);
            try {
                TimeUnit.SECONDS.sleep(5);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        @Override
        public String toString(){
            return getClass() + "{" + 
                "name='"+name+"'" + 
            "}";
            }
    }

    public static void main(String[] args){
        ThreadPoolExecutor executor = new ThreadPoolExecutor(1,
        1,
        60L,
        TimeUnit.SECONDS,
        new ArrayBlockingQueue<Runnable>(1),
        Executors.defaultThreadFactory(),
        (r,executors) -> {
            //自定义饱和策略
            //记录一下无法处理的任务
            System.out.println("无法处理的任务："+ r.toString() );
        });

        for (int i = 0; i < 5; i++) {
            executor.execute(new Task("任务-" + i));
        }
        executor.shutdown();
    }
}

输出：

无法处理的任务：class aboutThread.Concurrent.Day18.Demo5$Task{name='任务-2'}
pool-1-thread-1处理任务-0
无法处理的任务：class aboutThread.Concurrent.Day18.Demo5$Task{name='任务-3'}
无法处理的任务：class aboutThread.Concurrent.Day18.Demo5$Task{name='任务-4'}
pool-1-thread-1处理任务-1

输出结果中可以看出有3个任务进入了饱和策略中，记录了任务的日志，对于无法处理的任务，我们最好记录一下，让开发人员能够知道。任务进入了饱和策略，说明线程池的配置不是太合理，或者机器的性能有限，需要做有些优化调整。

线程池中的2个关闭方法

线程池提供了2个关闭方法： shutdown 和 shutdownNow，当调用这两个方法之后，线程池会遍历内部的工作线程，然后调用每个工作线程的interrupt方法给线程发送中断信号，内部如果无法响应中断信号的可能永远无法终止，所以如果内部有无限循环的，最好在循环内部检测一下线程的中断信号，合理的退出。调用这两个方法中的任意一个，线程池的isShutDown 方法就会返回true，当所有的任务线程都关闭之后，才表示线程池关闭成功，这时调用 isTerminated 方法会 返回true。

调用shutdown方法之后，线程池将不再接受新任务，内部会将所有已提交的任务处理完毕，处理完毕之后，工作线程自动退出。

而调用shutdownNow方法后，线程池会将还未处理的（在队里等待处理的任务）任务移除，将正在处理中的处理完毕之后，工作线程自动退出。

至于调用哪个方法来关闭线程，应该由提交到线程池任务特性决定，多数情况下调用 shutdown 方法来关闭线程池，如果任务不一定要执行完，则可以调用shutdownNow方法。

扩展线程池

虽然jdk提供了ThreadPoolExecutor这个高性能线程池，但是如果我们自己想在这个线程池上面做一些扩展，比如，监控每个任务执行的开始时间，结束时间，或者一些其他自定义的功能，我们应该怎么办？

这个jdk已经帮我们想到了，ThreadPoolExecutor内部提供了几个方法 beforeExecute、afterExecute、terminated，可以由开发人员决定，看一下线程池内部的源码：

try {
    beforeExecute(wt, task);//任务执行之前调用的方法
    Throwable thrown = null;
    try {
        task.run();
    } catch (RuntimeException x) {
        thrown = x;
        throw x;
    } catch (Error x) {
        thrown = x;
        throw x;
    } catch (Throwable x) {
        thrown = x;
        throw new Error(x);
    } finally {
        afterExecute(task, thrown);//任务执行完毕之后调用的方法
    }
} finally {
    task = null;
    w.completedTasks++;
    w.unlock();
}

beforeExecute：任务执行之前调用的方法，有2个参数，第1个参数是执行任务的线程，第2个参数是任务

protected void beforeExecute(Thread t,Runnable r){ }

afterExecute：任务执行完成之后调用的方法，2个参数，第1个参数表示任务，第2个参数表示任务执行时的异常信息，如果无异常，第2个参数为null

protected void afterExecute(Runnable r,Throw t){ }

terminated ：线程池最终关闭之后调用的方法。所有的工作线程都退出了，最终线程池会退出，退出时调用该方法

package aboutThread.Concurrent.Day18;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class Demo6 {
    static class Task implements Runnable{
       String name;

        public Task(String name){
            this.name = name;
        }
        @Override
        public void run() {
             System.out.println(Thread.currentThread().getName() + "处理" + this.name);
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            }
            public String toString() {
                return "Task{" +
                        "name='" + name + '\'' +
                        '}';
            }
    }

    public static void main(String[] args)  throws InterruptedException{
        ThreadPoolExecutor executor = new ThreadPoolExecutor(10,
        10,
        60L,
        TimeUnit.SECONDS,
        new ArrayBlockingQueue<Runnable>(1),
        Executors.defaultThreadFactory(),
        (r,executors) -> {
              //自定义饱和策略
              //记录一下无法处理的任务
              System.out.println("无法处理的任务：" + r.toString());   
        }){
            @Override
            protected void beforeExecute(Thread t, Runnable r) {
                System.out.println(System.currentTimeMillis() + "," + t.getName() + ",开始执行任务:" + r.toString());
            }

            @Override
            protected void afterExecute(Runnable r, Throwable t) {
                System.out.println(System.currentTimeMillis() + "," + Thread.currentThread().getName() + ",任务:" + r.toString() + "，执行完毕!");
            }

            @Override
            protected void terminated() {
                System.out.println(System.currentTimeMillis() + "," + Thread.currentThread().getName() + "，关闭线程池!");
            }
        };

        for (int i = 0; i < 10; i++) {
            executor.execute(new Task("任务-" + i));
        }
        TimeUnit.SECONDS.sleep(1);
        executor.shutdown();
    }
}

输出：

1591189466472,pool-1-thread-1,开始执行任务:Task{name='任务-0'}
1591189466472,pool-1-thread-4,开始执行任务:Task{name='任务-3'}
1591189466472,pool-1-thread-2,开始执行任务:Task{name='任务-1'}
1591189466472,pool-1-thread-3,开始执行任务:Task{name='任务-2'}
1591189466472,pool-1-thread-5,开始执行任务:Task{name='任务-4'}
pool-1-thread-2处理任务-1
pool-1-thread-4处理任务-3
pool-1-thread-1处理任务-0
1591189466473,pool-1-thread-6,开始执行任务:Task{name='任务-5'}
pool-1-thread-5处理任务-4
pool-1-thread-3处理任务-2
pool-1-thread-6处理任务-5
1591189466473,pool-1-thread-7,开始执行任务:Task{name='任务-6'}
1591189466473,pool-1-thread-8,开始执行任务:Task{name='任务-7'}
pool-1-thread-8处理任务-7
pool-1-thread-7处理任务-6
1591189466473,pool-1-thread-9,开始执行任务:Task{name='任务-8'}
pool-1-thread-9处理任务-8
1591189466473,pool-1-thread-10,开始执行任务:Task{name='任务-9'}
pool-1-thread-10处理任务-9
1591189468476,pool-1-thread-3,任务:Task{name='任务-2'}，执行完毕!
1591189468476,pool-1-thread-9,任务:Task{name='任务-8'}，执行完毕!
1591189468476,pool-1-thread-6,任务:Task{name='任务-5'}，执行完毕!
1591189468476,pool-1-thread-7,任务:Task{name='任务-6'}，执行完毕!
1591189468476,pool-1-thread-10,任务:Task{name='任务-9'}，执行完毕!
1591189468476,pool-1-thread-8,任务:Task{name='任务-7'}，执行完毕!
1591189468476,pool-1-thread-4,任务:Task{name='任务-3'}，执行完毕!
1591189468476,pool-1-thread-5,任务:Task{name='任务-4'}，执行完毕!
1591189468476,pool-1-thread-1,任务:Task{name='任务-0'}，执行完毕!
1591189468476,pool-1-thread-2,任务:Task{name='任务-1'}，执行完毕!
1591189468477,pool-1-thread-2，关闭线程池!

从输出结果中可以看出，每个需要执行的任务打印了3行日志，执行前由线程池的 beforeExecute 打印，执行时会调用任务的 run 方法，任务执行完毕之后，会调用线程池的 afterExecute 方法，从每个任务的首尾2条日志中可以看出每个任务耗时2秒左右。线程池最终关闭之后调用了termianted方法。

合理地配置线程池

要想合理的配置线程池，需要先分析任务的特性，可以从几个角度分析：

  • 任务的性质：CPU密集型任务、IO密集型任务和混合型任务
  • 任务的优先级：高、中、低
  • 任务的执行时间：长、中、短
  • 任务的依赖性：是否依赖其他的系统资源，如数据库连接。

性质不同任务可以用不同规模的线程池分开处理。CPU密集型任务应该尽可能小的线程，如配置CPU数量+1个线程的线程池。由于IO密集型任务并不是一直在执行任务，不能让cpu闲着，则应配置尽可能多的线程，如：cpu数量 * 2。混合型的任务，如果可以拆分，将其拆分成一个CPU密集型任务和一个IO密集型任务，只要这2个任务执行的时间相差不是太大，那么分解后执行的吞吐量将高于串行执行的吞吐量。可以通过 Runtime.getRuntime().availableProcessors() 方法获取cpu数量。优先级不同任务可以对线程池采用优先级队列来处理，让优先级高的先执行。

使用队列的时候建议使用有界队列，有界队列增加了系统稳定性，如果采用无界队列，任务太多的时候可能导致系统OOM，直接让系统宕机。

线程池中线程数量的配置

线程池中总线程大小对系统的性能有一定的影响，我们的目标是希望系统能够发挥最好的性能，过多或者过少的线程数量无法有效的使用机器的性能。

在Java Concurrency in Priactice书中给出了估算线程池大小的公式：

Ncpu = cpu的数量
Ucpu = 目标cpu的使用率，0 <= Ucpu <= 1
W/C = 等待时间与计算时间的比例
为保存处理器达到期望的使用率，最优的线程池大小等于：
Nthreads = Ncpu * Ucpu * （1 + W/C）

一些使用建议

在《阿里巴巴java开发手册》 中指出了线程资源必须通过线程池提供，不允许在应用中自行显式的创建线程，这样一方面是线程的创建更加规范，可以合理控制开辟线程的数量；另一方面线程的细节管理交给线程池处理，优化了资源的开销。而线程池不允许使用Executors去创建，而要通过ThreadPoolExecutor方式，这一方面是由Jdk中Executor框架虽然提供了如 newFixedThreadPool()、newSingleThreadExecutor()、newCachedThreadPool() 等方式创建线程池，但都有局限性，不够灵活；另外由于前面几种方法内部也是通过ThreadPoolExecutor方式实现，使用ThreadPoolExecutor有助于大家明确线程池的运行规则，创建符合自己业务场景需要的线程池，避免资源耗尽的风险。

这是Java并发学习的第18天，我们第19天见。

Aran_
关注
专栏目录
java高并发系列 - 第18天：JAVA线程池
专搞技术的小兔子
08-02 160
大家用jdbc操作过数据库应该知道，操作数据库需要和数据库建立连接，拿到连接之后才能操作数据库，用完之后销毁。数据库连接的创建和销毁其实是比较耗时的，真正和业务相关的操作耗时是比较短的。每个数据库操作之前都需要创建连接，为了提升系统性能，后来出现了数据库连接池，系统启动的时候，先创建很多连接放在池子里面，使用的时候，直接从连接池中获取一个，使用完毕之后返回到池子里面，继续给其他需要者使用，这其中就省去创建连接的时间，从而提升了系统整体的性能。
java高并发系列 - 第19天：JUC中的Executor框架详解1
专搞技术的小兔子
08-02 103
Executors框架是Doug Lea的神作，通过这个框架，可以很容易的使用线程池高效地处理并行任务。
JAVA多线程—Executors类的应用
此博客已停用，博文会逐渐转移到新地址，http://blog.csdn.net/liupeifeng3514
04-21 325
固定大小的线程池、缓存线程池、单一线程池代码示例：import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors;public class ThreadPoolTest { public static void main(String[] args) { ExecutorSer
java线程池thread pool使用总结
zpzkitt的专栏
12-14 9601
一、线程池的用途 线程池主要是为了解决以下几个问题： 1、为多线程执行琐碎的任务提供支持 2、避免线程创建销毁过程的资源消耗 3、控制资源的使用，根据实际情况合理高效利用资源 4、 二、java提供的线程池结构 java jdk中提供了线程池的创建接口，已经可以很方便对线程的管理和使用了。 上图是线程池和调度线程的UML图 1、创建线程就是用ThreadPoolExecuto...
ThreadPoolExecutor任务饱和策略
GaoJHIT的博客
11-06 778
引言 当使用线程池管理任务时，如果使用无界队列（LinkedBlockingQueue）的线程池（newFixedThreadPool和newSingleThreadExecutor默认使用一个无界队列），如果所有线程都在执行任务，那么任务将在队列中等待，如果任务到达的速度大于线程执行的速度，那么队列将无限期等待。 更稳妥的管理策略是使用有界队列，如：ArrayBlockingQueue，有界的LinkedBlockingQueue,PriorityBlockingQueue。有界队列避免了资源耗尽的情况
ThreadPoolExecutor的饱和策略——线程池
CrazyTiger的博客
10-14 1091
线程池的四种饱和策略说明。
java fatal exception_如何解决FATAL EXCEPTION：pool-4-thread-1错误？
weixin_42355421的博客
03-06 2944
我有一个工作得很好的应用程序，但有时候我在程序中添加了一些类和代码，导致我的应用程序崩溃。在我logcat错误是这样的：如何解决FATAL EXCEPTION：pool-4-thread-1错误？FATAL EXCEPTION: pool-4-thread-1，并在我的代码是这样的：reader = new BufferedReader(new InputStreamReader(httpURLC...
java高并发系列 - 第31天：获取线程执行结果，这6种方法你都知道(1)
2301_81694225的博客
04-09 349
上面代码也达到了预期效果，使用可以让一个或者多个线程等待一批线程完成之后，自己再继续；方式3：ExecutorService.submit方法实现代码：/*** 跟着阿里p7学并发，微信公众号：javacode2018*///创建一个线程池try {return 10;});//关闭线程池输出：使用方法实现的，此方法返回一个Future会让当前线程阻塞，直到Future关联的任务执行完毕。方式4：FutureTask方式1代码：/**
java高并发系列 - 第31天：获取线程执行结果，这6种方法你都知道
2301_81694225的博客
04-09 685
其实关于Kafka，能问的问题实在是太多了，扒了几天，最终筛选出44问：基础篇17问、进阶篇15问、高级篇12问，个个直戳痛点，不知道如果你不着急看答案，又能答出几个呢？若是对Kafka的知识还回忆不起来，不妨先看我手绘的知识总结脑图（xmind不能上传，文章里用的是图片版）进行整体架构的梳理梳理了知识，刷完了面试，如若你还想进一步的深入学习解读kafka以及源码，那么接下来的这份《手写“kafka”》将会是个不错的选择。Kafka入门为什么选择KafkaKafka的安装、管理和配置。
【Java基础知识 1】Java入门级概述
热门推荐
学Java，找哪吒
09-25 15万+
CSDN最强Java专栏，包含全部Java基础知识点、Java8新特性、Java集合、Java多线程、Java代码实例，理论结合实战，实现Java的轻松学习。
关于：程序中threadName:pool-4637-thread-4是什么意思？问题
qq_34207898的博客
09-29 2129
描述：在一次使用线程池过程中，服务器日志出现pool-4637-thread-4。心生疑问，网上也有人提出疑问。 我这边出现的原因是： ExecutorService fixedThreadPool = Executors.newFixedThreadPool(10); 这个定义在了for循环中，导致了会创建多个线程池。 这个问题对服务器是危险的，所以按理说线程池应该在所有循环代码...
线程池之ThreadPool类与辅助线程 - <第二篇>
ajwqb06628的专栏
03-28 692
线程池之ThreadPool类与辅助线程 - <第二篇> 一、CLR线程池 　　管理线程开销最好的方式： 尽量少的创建线程并且能将线程反复利用(线程池初始化时没有线程，有程序请求线程则创建线程)； 最好不要销毁而是挂起线程达到避免性能损失(线程...
java线程池1-线程池，ThreadPoolExecutor类详解
5big的博客
12-13 451
1.线程池的概念多线程技术主要用于解决处理器单元内多个线程执行的问题，她可以显著减少处理器单元的闲置时间，增减处理器单元的吞吐能力。 多数生产环境面临的技术背景一般是：处理一次请求的时间是短暂的，但是请求数量巨大，这种情况如果为每一个请求都单独创建一个县城，那么资源基本都被创建线程，切换线程，销毁线程所占据，用于业务请求的资源反而少 理想的处理方式是：将处理请求的线程数量控制在一个范围，既保证后
java syncqueue_Java并发包之同步队列SynchronousQueue理解
weixin_35626408的博客
02-19 280
1 简介SynchronousQueue是这样一种阻塞队列，其中每个put必须等待一个take，反之亦然。同步队列没有任何内部容量，甚至连一个队列的容量都没有。不能在同步队列上进行peek，因为仅在试图要取得元素时，该元素才存在，除非另一个线程试图移除某个元素，否则也不能(使用任何方法)添加元素，也不能迭代队列，因为其中没有元素可用于迭代。队列的头是尝试添加到队列中的首个已排队线程元素，如果没有已...
java syncqueue_java多线程之：SynchronousQueue队列
weixin_36476826的博客
02-19 440
SynchronousQueue是这样一种阻塞队列，其中每个 put 必须等待一个 take，反之亦然。同步队列没有任何内部容量，甚至连一个队列的容量都没有。不能在同步队列上进行 peek，因为仅在试图要取得元素时，该元素才存在；除非另一个线程试图移除某个元素，否则也不能(使用任何方法)添加元素;也不能迭代队列，因为其中没有元素可用于迭代。队列的头是尝试添加到队列中的首个已排队线程元素； 如果没有...
Java语言编写计算器
BTboay
03-15 10万+
本文讲述Java图形用户界面的编写，重点讲述一个简单计算器的实现。文中程序的运行环境为Windows10 ，编译环境为MyEclipse 8.5。一个简单的计算器主要实现一下功能和要求：一：输入，输出     ①输入：允许输入带有括号的完整计算式（例 6*（3+5）-5÷2）     ②输出：输出Double类型的结果二：功能     ①：基本的加，减，乘，除，四则运算     ②：平方运算   ...
Java运算符的使用和规则
Aunero的博客
05-30 1744
本篇文章为本人学习笔记，如有错误，希望指正。 Java中运算符大致分为以下几类： 算数运算符 赋值运算符 自增自减运算符 关系运算符 逻辑运算符 三元运算符 1. 算数运算符 算数运算符包括： 作用 + 加法运算，字符串连接运算 - 减法运算 * 乘法运算 / 除法运算 % 取模运算，两个数字相除取余数 注意：/和%的区别：两个数据做除法，/取结果的商，%取结果的余数。 整数操作只能得到整数，要想得到小数，必须有浮点数参与运算。 1.1 字符串的 + 操作.
java阻塞队列之SychronousQueue
大佬请赐教
01-01 371
SynchronousQueue原理详解-公平模式https://www.cnblogs.com/dwlsxj/p/Thread.html SynchronousQueue原理详解-非公平模式https://www.cnblogs.com/dwlsxj/p/synchronousqueue-unfair-pattern.html
工厂模式的介绍及实现
最新发布
户伟伟的博客
09-25 69
工厂模式（Factory Pattern）是一种创建型设计模式，提供了一种创建对象的接口，而无需显式指定对象的具体类。在这种模式中，我们通过定义一个工厂类，专门负责生产各种类型的对象，这样我们可以避免直接在代码中实例化具体类，使代码更具扩展性、灵活性和维护性。解耦：客户端代码与具体的类解耦，避免了对象创建逻辑的重复。简化对象创建：通过工厂统一管理对象的创建逻辑，使代码更清晰易懂。扩展性强：新增类时，只需在工厂中增加创建逻辑，而不必修改现有的业务代码。
Java并发编程：线程池深度解析与ForkJoin框架
"Java 高并发六：JDK并发包2详解，涵盖了线程池的基本使用、扩展和增强，以及ForkJoin框架的讲解。" 在Java编程中，高并发处理是性能优化的关键部分，而JDK并发包提供了丰富的工具和类来支持高效的并发操作。本文将...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值