线程池——彻底解析

最新推荐文章于 2024-02-26 10:26:26 发布
最新推荐文章于 2024-02-26 10:26:26 发布
阅读量2.1k 收藏 5
点赞数 3
分类专栏： Java基础 文章标签： 队列 java 多线程 线程池
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_55086330/article/details/114993523
版权

基本简介

什么是线程池，为什么使用线程池？

线程池其实就是一种多线程处理形式，处理过程中可以将任务添加到队列中，然后在创建线程后自动启动这些任务。这里的线程就是我们前面学过的线程,这里的任务就是我们前面学过的实现了Runnable或Callable接口的实例对象。

使用线程池最大的原因就是可以根据系统的需求和硬件环境灵活的控制线程的数量，且可以对所有线程进行统一的管理和控制，从而提高系统的运行效率，降低系统运行压力。当然了使用线程池的原因不仅仅只有这些，我们可以从线程池自身的优点上来进一步了解线程池的好处。

所以就可以总结出线程池的优势：

  • 线程和任务分离，提升线程重用性
  • 控制线程并发数量，降低服务器压力，统一管理所有线程
  • 提升系统响应速度，假如创建线程用的时间为T1，执行任务用的时间为T2，销毁线程用的时间为T3，那么使用线程池就免去了T1和T3的时间

构造方法参数

参数介绍

首先是代码如下：

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

涉及到7个参数：以及设计原则

  • corePoolSize：核心线程数（这个是必须的，创建了就不会被销毁）

    核心线程数的设计需要依据任务的处理时间和每秒产生的任务数量来确定，例如：执行一个任务需要0.1秒，系统有大概80%的时间每秒都会产生100个任务，那么要想在1秒内处理完这100个任务，就需要10个线程，此时我们就可以设计核心线程数为10。剩下的20%可以交给最大线程数。

  • maximumPoolSize：线程池最大线程数（比核心线程数大，就可以有零时线程，用完过一段时间就销毁）

    最大线程数的设计除了需要参照核心线程数的条件外，还需要参照系统每秒产生的最大任务数决定。例如：上述环境中，如果系统每秒最大产生的任务是1000个，那么，最大线程数=(最大任务数-任务队列长度)，单个任务执行时间。既:：最大线程数=(1000-200)*0.1=80个

  • keepAliveTime：线程池中非核心线程空闲的存活时间大小

    这个玩意就是有时候使用到了非核心线程，然后执行完之后，这些非核心线程可以存活的时间。

  • unit：线程空闲存活时间，就是上面存活时间的单位。

  • workQueue：存放任务的阻塞队列

    任务队列长度一般设计为：核心线程数/单个任务执行时间*2即可。例如上面的场景中，核心线程数设计为10，单个任务执行时间为0.1秒，则队列长度可以设计为200

  • threadFactory： 用于设置创建线程的工厂，可以给创建的线程设置有意义的名字，可方便排查问题

  • Handler：线城池的饱和策略事件，主要有四种类型。

参数的理解：假设一个银行有有两个核心业务员工（就好比是核心线程数），然后有一个经理（非核心线程），这个时候最大线程数为3，来了两个用户ab，此时核心员工为他们服务，然后又来一个c，此时的c就到大厅等待（好比任务队列），然后又来几个人，把大厅坐满了，后面还来，忙不过来了，这个时候经理上线被迫工作。

这可以看出几个等价关系式：maximumPoolSize = corePoolSize + workQueue

工作流程

在这里插入图片描述

任务队列

ArrayBlockingQueue

ArrayBlockingQueue（有界队列）是一个用数组实现的有界阻塞队列，按FIFO排序量。也就是我们需要指定这个队列的长度。

LinkedBlockingQueue

LinkedBlockingQueue（可设置容量队列）基于链表结构的阻塞队列，按FIFO排序任务，容量可以选择进行设置，不设置的话，将是一个无边界的阻塞队列，最大长度为Integer.MAX_VALUE，吞吐量通常要高于ArrayBlockingQuene；newFixedThreadPool线程池使用了这个队列。

如果不设置大小，有时候任务执行时间一长，又在不断地产生新的任务，就会造成OOM，内存溢出。

DelayQueue

DelayQueue（延迟队列）是一个任务定时周期的延迟执行的队列。根据指定的执行时间从小到大排序，否则根据插入到队列的先后排序。newScheduledThreadPool线程池使用了这个队列。

PriorityBlockingQueue

PriorityBlockingQueue（优先级队列）是具有优先级的无界阻塞队列；

SynchronousQueue

SynchronousQueue（同步队列）一个不存储元素的阻塞队列，每个插入操作必须等到另一个线程调用移除操作，否则插入操作一直处于阻塞状态，吞吐量通常要高于LinkedBlockingQuene，newCachedThreadPool线程池使用了这个队列。

也就是说这个队列如果有任务，插入任务时候会被阻塞，直到队列中的任务被取出消费掉。同理，如果队列中没有任务，线程消费时候，会处于阻塞状态，直到这个队列中有了新的任务。

其他的也没多大新奇。只需要关注这三个就行了。

拒绝策略

当线程池的线程数达到最大线程数时，需要执行拒绝策略。拒绝策略需要实现RejectedExecutionHandler接口，并实现rejectedExecution(Runnable r, ThreadPoolExecutor executor)方法。不过Executors框架已经为我们实现了4种拒绝策略：

  • AbortPolicy(抛出一个异常，默认的)

    丢弃任务并抛出RejectedExecutionException异常。

  • DiscardPolicy(直接丢弃任务)

    丢弃任务，但是不抛出异常。可以配合这种模式进行自定义的处理方式。丢弃的是后面的加入的任务

  • DiscardOldestPolicy（丢弃队列里最老的任务，将当前这个任务继续提交给线程池）

    丢弃的是任务队列中前面的任务

  • CallerRunsPolicy（交给线程池调用所在的线程进行处理)

    由调用线程处理该任务。也就是哪个线程创建这个线程池，然后线程池就丢给创建它的线程处理。

//使用原生的创建方式，这也是阿里推荐的方式
public void testCreatePool(){
    ThreadPoolExecutor executor = new ThreadPoolExecutor(1,2,
            2, TimeUnit.SECONDS,new ArrayBlockingQueue<Runnable>(3),
            new ThreadPoolExecutor.AbortPolicy());
}

自定义线程池

通过模拟来更加了解线程池。

自定义任务类

任务即需要被执行的东西，通常而言都会规定一个任务的接口，然后实现接口，这个接口就是我们需要执行的玩意。这里假设直接使用Runnable接口：（注意，这里是不过是用Runnable接口，并不是说这个玩意是一个线程）

/**
    需求:
        自定义线程池练习,这是任务类,需要实现Runnable;
        包含任务编号,每一个任务执行时间设计为0.2秒
 */
public class MyTask implements Runnable{
    private int id;
    //由于run方法是重写接口中的方法,因此id这个属性初始化可以利用构造方法完成

    public MyTask(int id) {
        this.id = id;
    }

    @Override
    public void run() {
        String name = Thread.currentThread().getName();
        System.out.println("线程:"+name+" 即将执行任务:"+id);
        try {
            Thread.sleep(200);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("线程:"+name+" 完成了任务:"+id);
    }

    @Override
    public String toString() {
        return "MyTask{" +
                "id=" + id +
                '}';
    }
}

自定义线程类

既然有了任务，就需要线程需执行：（注意线程是需要从多个任务中获取来执行的）

/**
    需求:
        编写一个线程类,需要继承Thread类,设计一个属性,用于保存线程的名字;
        设计一个集合,用于保存所有的任务;
 */
public class MyWorker extends Thread{
    private String name;//保存线程的名字
    private List<Runnable> tasks;
    //利用构造方法,给成员变量赋值

    public MyWorker(String name, List<Runnable> tasks) {
        super(name);
        this.tasks = tasks;
    }

    @Override
    public void run() {
        //判断集合中是否有任务,只要有,就一直执行任务
        while (tasks.size()>0){
            Runnable r = tasks.remove(0);
            r.run();	//调用的是run，直接执行方法，而不是启动线程
        }
    }
}

自定义线程池

怎么管理任务，线程，就需要一个核心的线程池：

/**
    这是自定义的线程池类;

    成员变量:
        1:任务队列   集合  需要控制线程安全问题
        2:当前线程数量
        3:核心线程数量
        4:最大线程数量
        5:任务队列的长度
    成员方法
        1:提交任务;
            将任务添加到集合中,需要判断是否超出了任务总长度
        2:执行任务;
            判断当前线程的数量,决定创建核心线程还是非核心线程
 */
public class MyThreadPool {
    // 1:任务队列   集合  需要控制线程安全问题
    private List<Runnable> tasks = Collections.synchronizedList(new LinkedList<>());
    //2:当前线程数量
    private int num;
    //3:核心线程数量
    private int corePoolSize;
    //4:最大线程数量
    private int maxSize;
    //5:任务队列的长度
    private int workSize;

    public MyThreadPool(int corePoolSize, int maxSize, int workSize) {
        this.corePoolSize = corePoolSize;
        this.maxSize = maxSize;
        this.workSize = workSize;
    }

    //1:提交任务;
    public void submit(Runnable r){
        //判断当前集合中任务的数量,是否超出了最大任务数量
        if(tasks.size()>=workSize){
            System.out.println("任务:"+r+"被丢弃了...");
        }else {
            tasks.add(r);
            //执行任务
            execTask(r);
        }
    }
    //2:执行任务;
    private void execTask(Runnable r) {
        //判断当前线程池中的线程总数量,是否超出了核心数,
        if(num < corePoolSize){
            new MyWorker("核心线程:"+num,tasks).start();
            num++;
        }else if(num < maxSize){
            new MyWorker("非核心线程:"+num,tasks).start();
            num++;
        }else {
            System.out.println("任务:"+r+" 被缓存了...");
        }
    }
}

然后就是测试了，直接创建一个线程池，然后放任务：

public static void main(String[] args) {
    //创建线程池
    MyThreadPool pool = new MyThreadPool(2, 4, 20);
    //创建任务提交并执行
    for (int i = 0; i < 40; i++) {
        pool.submit(new MyTask(i));
    }
}

[ 注意 ]：这里必须是在main方法测试，使用@Test这玩意是体现不出来的

内置线程池-ExecutorService

这几种方式都是需要使用Executors来构建的。

这里只列举几种常见的

通用的方法

  • void shutdown() 启动一次顺序关闭，执行以前提交的任务，但不接受新任务
public static void main(String[] args) throws InterruptedException {
    //Executors.newCachedThreadPool()获取ExecutorService
    ExecutorService executorService = Executors.newCachedThreadPool((Runnable r) -> {
        int n = 0;
        return new Thread(r,"自定义线程"+n++);
    });
    for (int i = 0; i < 20; i++) {
        Thread.sleep(100);
        executorService.submit(new MyRunnable(i));
    }
    executorService.shutdown();
    //会报错，因为调用shutdown方法之后就不能提交新的任务
    //错误类型：java.util.concurrent.RejectedExecutionException
    executorService.submit(new MyRunnable(2));  
}
  • List<Runnable> shutdownNow() 停止所有正在执行的任务，暂停处理正在等待的任务，并返回等待执行的任务列表
public static void main(String[] args) throws InterruptedException {
    //Executors.newCachedThreadPool()获取ExecutorService
    ExecutorService executorService = Executors.newCachedThreadPool((Runnable r) -> {
        int n = 0;
        return new Thread(r,"自定义线程"+n++);
    });
    for (int i = 0; i < 20; i++) {
        executorService.submit(new MyRunnable(i));
    }
    List<Runnable> runnables = executorService.shutdownNow();
}

newCachedThreadPool

创建一个默认的线程池对象,里面的线程可重用,且在第一次使用时才创建：

代码如下：(只需要任务提交就会给线程执行)

public class Test {
    public static void main(String[] args) {
        //Executors.newCachedThreadPool()获取ExecutorService
        ExecutorService executorService = Executors.newCachedThreadPool();
        for (int i = 0; i < 20; i++) {
            executorService.submit(new MyRunnable(i));
        }

    }
}
/**
 *  任务类,包含一个任务编号,在任务中,打印出是哪一个线程正在执行任务
 */
class MyRunnable implements Runnable{
    private  int id;
    public MyRunnable(int id) {
        this.id = id;
    }

    @Override
    public void run() {
        //获取线程的名称,打印一句话
        String name = Thread.currentThread().getName();
        System.out.println(name+"执行了任务..."+id);
    }
}

源码如下：

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

默认创建一个无核心线程的线程池。

当提交任务的速度大于处理任务的速度时，每次提交一个任务，就必然会创建一个线程。极端情况下会创建过多的线程，耗尽 CPU 和内存资源。由于空闲 60 秒的线程会被终止，长时间保持空闲的 CachedThreadPool 不会占用任何资源。

在这里插入图片描述

构造方法重载：

public class Test {
    public static void main(String[] args) throws InterruptedException {
        //Executors.newCachedThreadPool()获取ExecutorService
        ExecutorService executorService = Executors.newCachedThreadPool((Runnable r) -> {
            int n = 0;
            return new Thread(r,"自定义线程"+n++);
        });
        for (int i = 0; i < 20; i++) {
            Thread.sleep(100);
            executorService.submit(new MyRunnable(i));
        }

    }
}
/**
 *  任务类,包含一个任务编号,在任务中,打印出是哪一个线程正在执行任务
 */
class MyRunnable implements Runnable{
    private  int id;
    public MyRunnable(int id) {
        this.id = id;
    }

    @Override
    public void run() {
        //获取线程的名称,打印一句话
        String name = Thread.currentThread().getName();
        System.out.println(name+"执行了任务..."+id);
    }
}

线程池中的所有线程都使用ThreadFactory来创建，这样的线程无需手动启动，自动执行。简言之就是可以使用这种方式来自定义执行的线程，之前都是使用默认的。

用于并发执行大量短期的小任务。

newFixedThreadPool

创建一个可重用固定线程数的线程池：

public class Test1 {
    public static void main(String[] args) throws InterruptedException {
        //Executors.newCachedThreadPool()获取ExecutorService
        ExecutorService executorService = Executors.newFixedThreadPool(3);
        for (int i = 0; i < 20; i++) {
            Thread.sleep(100);
            executorService.submit(new MyRunnable(i));
        }

    }
}

源码如下：

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

这种方式的特点：

  • 核心线程数和最大线程数大小一样
  • 没有所谓的非空闲时间，即keepAliveTime为0
  • 阻塞队列为无界队列LinkedBlockingQueue

在这里插入图片描述

同样这个可以定义ThreadFactory来自定义创建的线程长啥样：

public static void main(String[] args) throws InterruptedException {
    //Executors.newCachedThreadPool()获取ExecutorService
    ExecutorService executorService = Executors.newFixedThreadPool(3,(Runnable r) -> {
        int n = 0;
        return new Thread(r,"自定义线程"+n++);
    });
    for (int i = 0; i < 20; i++) {
        //Thread.sleep(1);
        executorService.submit(new MyRunnable(i));
    }
}

FixedThreadPool 适用于处理CPU密集型的任务，确保CPU在长期被工作线程使用的情况下，尽可能的少的分配线程，即适用执行长期的任务。

newSingleThreadExecutor

创建一个使用单个 worker 线程的 Executor，以无界队列方式来运行该线程。

使用方式如下：

public static void main(String[] args) throws InterruptedException {
    //Executors.newCachedThreadPool()获取ExecutorService
    ExecutorService executorService = Executors.newSingleThreadExecutor();
    /*ExecutorService executorService = Executors.newSingleThreadExecutor(3,(Runnable r) -> {
            int n = 0;
            return new Thread(r,"自定义线程"+n++);
        });*/
    for (int i = 0; i < 20; i++) {
        //Thread.sleep(1);
        executorService.submit(new MyRunnable(i));
    }
}

源码如下：

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

直接创建一个线程，相当于单线程运行了。

在这里插入图片描述

当前的唯一线程，从队列取任务，执行完一个，再继续取，一个人（一条线程）夜以继日地干活。

同理也可以自定义线程创建方式：

public static void main(String[] args) throws InterruptedException {
    //Executors.newCachedThreadPool()获取ExecutorService
    //ExecutorService executorService = Executors.newSingleThreadExecutor();
    ExecutorService executorService = Executors.newSingleThreadExecutor((Runnable r) -> {
        int n = 0;
        return new Thread(r,"自定义线程"+n++);
    });
    for (int i = 0; i < 20; i++) {
        //Thread.sleep(1);
        executorService.submit(new MyRunnable(i));
    }
}

适用于串行执行任务的场景，一个任务一个任务地执行。

newScheduledThreadPool

创建一个可重用固定线程数的线程池且允许延迟运行或定期执行任务;

public static void main(String[] args) throws InterruptedException {
    //Executors.newCachedThreadPool()获取ExecutorService
    ExecutorService executorService = Executors.newScheduledThreadPool(3);
    /*ExecutorService executorService = Executors.newScheduledThreadPool(3,(Runnable r) -> {
        int n = 0;
        return new Thread(r,"自定义线程"+n++);
    });*/
    for (int i = 0; i < 20; i++) {
        //Thread.sleep(1);
        executorService.submit(new MyRunnable(i));
    }
}

源码如下：

public ScheduledThreadPoolExecutor(int corePoolSize) {
    super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,
          new DelayedWorkQueue());
}

该线程池的特点：（核心线程数可自定义）

  • 最大线程数为Integer.MAX_VALUE
  • 阻塞队列是DelayedWorkQueue
  • keepAliveTime为0
  • scheduleAtFixedRate() ：按某种速率周期执行
  • scheduleWithFixedDelay()：在某个延迟后执行

三个重要的方法

  • public ScheduledFuture<?> schedule(Runnable command,long delay, TimeUnit unit);

这个方法是延时执行，参数1为任务，参数2为延时时间长度，参数三为这个时间的单位。

public static void main(String[] args) throws InterruptedException {
    //Executors.newCachedThreadPool()获取ExecutorService
    ScheduledExecutorService executorService = Executors.newScheduledThreadPool(3);
    for (int i = 0; i < 20; i++) {
        //启动会发现，等了5秒这这executorService才开始工作，只延时一次
        executorService.schedule(new MyRunnable(i),5, TimeUnit.SECONDS);
    }
}
  • scheduleAtFixedRate(Runnable command, long initialDelay, long period, TimeUnit unit)

循环任务，初始化延迟initialDelay开始执行，每隔period重新执行一次任务：

public static void main(String[] args) throws InterruptedException {
    //Executors.newCachedThreadPool()获取ExecutorService
    ScheduledExecutorService executorService = Executors.newScheduledThreadPool(3);

    for (int i = 0; i < 20; i++) {
        //Thread.sleep(1);
        executorService.scheduleAtFixedRate(new MyRunnable(i),2,4, TimeUnit.SECONDS);
    }
}

这个例子刚开始会延时2S，然后执行这些任务，然后不断延时4S一次执行。假设任务需要执行2s，

  • scheduleWithFixedDelay(Runnable command, long initialDelay, long delay, TimeUnit unit)

创建并执行一个在给定初始延迟后首次启用的定期操作，随后，在每一次执行终止和下一次执行开始之间都存在给定的延迟。

public static void main(String[] args) throws InterruptedException {
    //Executors.newCachedThreadPool()获取ExecutorService
    ScheduledExecutorService executorService = Executors.newScheduledThreadPool(3);

    for (int i = 0; i < 20; i++) {
        //Thread.sleep(1);
        executorService.scheduleWithFixedDelay(new MyRunnable(i),1,4, TimeUnit.SECONDS);
    }
}

总之后面这两个延时的策略是有区别的，后者会计算任务的处理时长，前者会在任务开始就进行计时。

工作机制

  • 添加一个任务
  • 线程池中的线程从 DelayQueue 中取任务
  • 线程从 DelayQueue 中获取 time 大于等于当前时间的task
  • 执行完后修改这个 task 的 time 为下次被执行的时间
  • 这个 task 放回DelayQueue队列中

周期性执行任务的场景，需要限制线程数量的场景

对比：

在这里插入图片描述

异步计算结果(Future)

常用方法：

  • boolean cancel(boolean mayInterruptIfRunning) ：如果参数为true并且任务正在运行，那么这个任务将被取消。如果参数为false并且任务正在运行，那么这个任务将不会被取消。
  • V get() ：一直等待，直到任务计算完成返回了结果。
  • V get(long timeout, TimeUnit unit) ：设置最多等待时间，到了时间还没有结果报异常
  • boolean isCancelled() ：如果在任务正常完成前将其取消，则返回 true。
  • boolean isDone()：如果任务已完成，则返回 true。
public class TestFuture {

    public static void main(String[] args) throws Exception {
        ExecutorService executorService = Executors.newCachedThreadPool();
        Future<Integer> future = executorService.submit(new MyCallable(1, 2));

        //boolean cancel = future.cancel(true);   //设置任务正在处理也可被取消
        //任务任务正常完成之前就取消了，就会返回true
        //System.out.println(future.isCancelled());   
        //System.out.println(cancel);
        
        //一直等待（会处于阻塞状态）
        //Integer integer = future.get();
        //System.out.println(integer);
        
        //最多等待3秒
        Integer integer = future.get(3, TimeUnit.SECONDS);
        System.out.println(integer);
    }
}

class MyCallable implements Callable<Integer>{
    private int a;
    private int b;

    public MyCallable(int a, int b) {
        this.a = a;
        this.b = b;
    }

    @Override
    public Integer call() throws Exception {
        System.out.println("开始计算");

        Thread.sleep(2000);
        int c = a+b;
        System.out.println("计算完成");
        return c;
    }
}
小王子jvm
关注
  • 3
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
线程池解析
学习
08-05 1068
线程池解析 java线程对应内核线程，创建与销毁需要切换到内核态，是系统开销较大的操作，因此需要设法复用线程。线程池就是一个线程缓存，负责对线程统一分配，调优与监控，线程池的优势： 提高性能：重用线程减少线程创建消亡的开销 提高响应速度：任务到达时可以立即执行，不需要再去创建线程 方便管理线程：便于统一分配、调控和监控 执行Runnable任务流程 简单说处理任务的优先级为：核心线程、任务队列、最大线程，如果三者都满了，使用handler处理被拒绝的任务。 具体如何实现的呢？ /** * 在将来某个时间执
线程池——线程池简介与应用（C++）
03-02
线程池的一个简介，包括什么是线程池，技术背景，线程池如何提高服务器的性能，如何使用线程池，线程池使用的时候应该注意的事项
线程池详细分析ThreadPoolExecutor
问彡心的博客
10-31 308
在使用线程中,为什么会用到线程池,?相比于用户自己创建Thread线程,有什么优点和不同. 线程池 线程是一个很重的资源,它的创建和销毁是一个比较好资源的操作,java中的线程属于KLT(内核级线程),所以线程的创建是由操作系统内核来完成的,那么当需要创建线程时,通过jvm映射到系统对外的接口中,在通过操作系统来分配线程资源,是一个相对比较重的操作,为避免线程的过度消耗需要对线程进行合理使用.线程池相当于一个线程缓存,对请求的线程进行同一分配,调度. 线程池适合做一些任务量大而处理时间短的操作 线程的优点:
彻底搞懂 Java 线程池，干啥都不再发憷
一猿小讲
07-25 2005
作为 Java 程序员，无论是技术面试、项目研发或者是学习框架源码，不彻底掌握 Java 多线程的知识，做不到心中有数，干啥都没底气，尤其是技术深究时往往略显发憷。没事，跟随小猿的脚步，...
0.9.2、线程池——核心线程数、阻塞队列、最大线程数之间的关系
༺ bestcxx的专栏 ༻
12-05 4617
文章目录线程池内部运行过程验证思路确保先提交的任务优先被线程池处理确保执行的任务占有足够久的线程池资源可观测的阻塞队列大小充分的信息代码自定义线程池结果结论基本几结论新任务提交在线程池内部处理的优先级 线程池内部运行过程 线程池的初始参数中包含 核心线程数、最大线程数、线程池线程空闲回收时间、阻塞队列、线程工厂、拒绝策略。 那么线程池是如何管理线程和阻塞队列的关系呢？ 验证思路 确保先提交的任务优先被线程池处理 多线程执行本身是无序的，原因在于并发操作下，后面提交的任务也可能被先运行，因此，为了确保先提交的
线程池线程数目的确定
laoyog
07-20 7925
在上一篇文章《java线程的创建(重点：线程池的使用，线程池不允许使用Executors创建)》中有关线程池的配置中， public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliv...
线程池源码解析-多线程
04-25
本文将深入解析线程池的源码，特别关注其中的`AtomicInteger`类以及线程池状态的表示。 `AtomicInteger`是Java并发包`java.util.concurrent.atomic`中的一个原子类型类，它提供了在多线程环境下安全地修改整型变量...
Java线程池解析.md
06-20
从线程池概念，到线程池的创建过程以及任务执行流程，结合案例分析，用最专业的术语和精湛的文字描述让带你彻底弄懂线程池。
线程池原理-ThreadPoolExecutor源码解析
11-17
线程池原理-ThreadPoolExecutor源码解析 1.构造方法及参数 2.阻塞对列: BlockingQueue 3.线程工厂: DefaultThreadFactory 4.拒绝策略: RejectedExecutionHandler 5.执行线程 Executor
四种Java线程池用法解析
09-02
Java线程池是Java并发编程中的重要组成部分，主要用于管理和调度线程资源，以提高系统的效率和稳定性。Java通过`java.util.concurrent.ExecutorService`接口和`java.util.concurrent.Executors`工厂类提供了四种...
线程池创建多少线程比较合理？(一文帮你理解)
程序员小乐
01-11 1865
点击上方 "程序员小乐"关注,星标或置顶一起成长每天凌晨00点00分,第一时间与你相约每日英文You’ll never find the right person, ...
线程池核心线程数最大线程数的意义
xajh_czbk的博客
06-10 3156
瓶口：最大线程数 瓶颈：队列 瓶身容量：核心线程数 线程池SingleThreadPool 和线程池FixedThreadPool wesi
java中的线程池
最新发布
qq_35693377的博客
02-26 1001
描述：核心线程池的大小，即线程池中始终保持存活的线程数量。作用：当有新的任务提交时，线程池会优先创建核心线程来处理任务。
面试必问的线程池-深入了解线程池的作用及原理
NoviceZ的博客
08-20 3984
线程池的作用 主要作用：避免创建过多的线程时引发的内存溢出问题。因为创建线程还是比较耗内存的，通常来说创建一个线程会默认分配1M的内存。 线程池的主要优势： 降低资源消耗。通过重复利用已创建的线程降低线程创建和销毁造成的消耗。 提高响应速度。当任务到达时，任务可以不需要等到线程创建就能立即执行。 提高线程的可管理性。线程是稀缺资源，如果无限制的创建，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一的分配，调优和监控。 线程池的使用 线程池的创建方式 线程池的真正实现类是Th..
【HBZ分享】java的线程池从创建 到 运行的原理
a645293829的博客
06-16 210
线程池原理
一文搞懂Java线程池执行原理&核心参数
qq_40187702的博客
07-09 1010
最近面试过程中经常被问到多线程方面的问题，尤其是线程池，因为这也是工作中常用的创建线程的方式，本篇博客在于记录自己对于线程池的执行原理及如何创建线程池去执行任务的一个理解，同时方便后期回顾复习这篇博客简单说了一下线程池的核心参数和执行原理，以及用一个小案例说明它的一个工作流程，后面会继续更新线程池方面的知识点，比如有哪些阻塞队列，它们内部的原理是什么。
理解线程池的原理
tyjlearning的博客
08-30 233
读完本文你将了解：   什么是线程池 线程池的处理流程 保存待执行任务的阻塞队列 创建自己的线程池 JDK 提供的线程池及使用场景 newFixedThreadPool newSingleThreadExecutor newCachedThreadPool newScheduledThreadPool 两种提交任务的方法 execute submit 关...
【非广告，纯干货】这大概是我看过最有温度的面经分享（已收割京东美团技术专家offer）
勇往直前的专栏
07-16 1448
说明：本文来源于中华石杉架构班学员 dasthinker 同学在拿下美团、京东两家互联网大厂技术专家offer之后的面经总结 简单自我介绍 本⼈是⼯作多年的⼀枚「⽼码农」，对⽐群⾥的年轻朋友们，是有点「⽼」哈，最近⼯作是在⼀家几百人规模的互联⽹公司⼯作。大家可能觉得，这个时期出来看机会，是往⽕坑⾥跳吗？ 个⼈不这么认为，借此疫情的特殊时期，通过企业市场招聘情况也能帮你把握⼀下⼤致业务发展⽅向，这其实是好事。 当然了，招聘岗位有限，狼多⾁少，岗位竞争肯定⽐往年更加激烈的，所以需要珍惜每⼀个机会。 .
为什么当线程池的核心线程满了后，是先加入到阻塞队列，而不是先创建新的线程？
绅士jiejie的博客
07-06 9388
核心线程满了后，再有任务需要执行，线程池为什么不继续创建新的线程呢，而是中间引入阻塞队列，能不能在核心线程满了后，继续创建线程，直到线程数达到最大线程数了，再把任务引入阻塞队列，这样的步骤不也是可以的？ 看了些回答，大致原因如下，总结下做个记忆： 线程池创建线程需要获取mainlock这个全局锁，会影响并发效率，所以使用阻塞队列把第一步创建核心线程与第三步创建最大线程隔离开来，起一个缓冲的作用。 引入阻塞队列，是为了在执行execute()方法时，尽可能的避免获取全局锁。 ...
ThreadPoolExecutor源码解析.pdf
11-26
这份PDF文档详细解析了ThreadPoolExecutor的源码，涵盖了线程池的状态转换、核心数据结构以及工作流程。” ThreadPoolExecutor是Java并发包`java.util.concurrent`中的核心类，用于管理和控制线程的执行。其主要...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值