并发编程之线程池

已于 2024-07-22 14:50:25 修改
阅读量309 收藏
点赞数
分类专栏： 多线程 文章标签： java
于 2017-12-17 20:37:46 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xhf852963/article/details/78827673
版权

 一、概念

        线程池就是一个复用线程的技术。

        如果不使用线程池，那么用户每发起一个请求，后台就需要创建一个新线程处理，下次新任务来了肯定又要创建新线程处理的，而创建线程的开销是很大的，并且请求过多时，肯定会产生大量的线程出来，这样会严重影响系统的性能。

二、创建线程池的方式

        JDK1.5 起提供了代表线程池的接口：ExecutorService

2.1 获取线程池对象

        方式一：使用 ExecutorService 的实现类 ThreadPoolExecutor 自创建一个线程池对象。

        方式二：使用 Executors （线程池工具类）调用方法返回不同特点的线程池对象。

2.2 ThreadPoolExecutor 构造器

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

        1、corePoolSize：指定线程池的核心线程的数量

        2、maximumPoolSize：指定线程池的最大线程数量

        3、keepAliveTime：指定临时线程的存活时间，假设核心线程数量为 3，最大线程数量为 5，那么临时线程数量就是 2，那么临时线程的存活时间说的就是这 2 个线程的存活时间。

        4、unit：指定临时线程的存活时间单位（秒、分、时、天）

        5、workQueue：指定线程池的阻塞队列

        6、threadFactory：指定线程池的线程工厂，可以为线程起个好名字

        7、handler：指定线程池的任务拒绝策略（线程都在忙且任务队列也满了的时候，新任务来了该如何出来）

2.3 工作原理

        1、线程池中刚开始没有线程，当一个任务提交给线程池后，线程池会创建一个新线程来执行任务。

        2、当线程数达到 corePoolSize 并没有线程空闲，这时再加入任务，新加的任务会被加入 workQueue 队列排队，直到有空闲的线程。

        3、如果队列选择了有界队列，那么任务超过了队列大小时，会创建 maximumPoolSize - corePoolSize 数目的线程来救急。

        4、如果线程到达 maximumPoolSize 仍然有新任务这时会执行拒绝策略。

        5、当高峰过去后，超过 corePoolSize 的救急线程如果一段时间没有任务做，需要结束节省资源，这个时间由 keepAliveTime 和 unit 来控制。

三、拒绝策略

        拒绝策略 jdk 提供了 4 种实现，其它著名框架也提供了实现。

3.1 jdk 拒绝策略

        1、AbortPolicy：让调用者抛出 RejectedExecutionException 异常，这是默认策略

        2、DiscardPolicy：放弃本次任务

        3、DiscardOldestPolicy：放弃队列中最早的任务，本任务取而代之

        4、CallerRunsPolicy：让调用者运行任务

3.2 其他拒绝策略

        1、Dubbo 的实现，在抛出 RejectedExecutionException 异常之前会记录日志，并 dump 线程栈信息，方便定位问题。

        2、Netty 的实现，是创建一个新线程来执行任务。

        3、ActiveMQ 的实现，带超时等待（60s）尝试放入队列，类似我们之前自定义的拒绝策略。

        4、PinPoint 的实现，它使用了一个拒绝策略链，会逐一尝试策略链中每种拒绝策略

四、线程池分类

4.1 newFixedThreadPool

        固定大小的线程池，构造方法代码如下所示：

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

4.1.1 特点

        核心线程数 == 最大线程数（没有临时线程被创建），因此也无需超时时间。并且阻塞队列是无界的，可以放任意数量的任务。

4.1.2 使用场景

        适用于任务量已知，相对耗时的任务。 

4.2 newCachedThreadPool

        缓存的线程池，构造方法代码如下所示：

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

4.2.1 特点

        核心线程数是 0， 最大线程数是 Integer.MAX_VALUE，救急线程的空闲生存时间是 60s，意味着全部都是救急线程（60s 后可以回收）临时线程可以无限创建。

        队列采用了 SynchronousQueue 实现特点是，它没有容量，没有线程来取是放不进去的（一手交钱、一手交货）。

        整个线程池表现为线程数会根据任务量不断增长，没有上限，当任务执行完毕，空闲 1 分钟后释放线程。

4.2.2 使用场景

         适合任务数比较密集，但每个任务执行时间较短的情况。

4.3 newSingleThreadExecutor

        单例的线程池，构造方法代码如下所示：

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

4.3.1 特点

        自己创建一个单线程串行执行任务，如果任务执行失败而终止那么没有任何补救措施，而线程池还会新建一个线程，保证池的正常工作。

4.3.2 使用场景

        希望多个任务排队执行。线程数固定为 1，任务数多于 1 时，会放入无界队列排队。任务执行完毕，这唯一的线程也不会被释放。

五、提交任务

5.1 执行任务

        语法如下：

// 执行任务
void execute(Runnable command);

        测试代码如下：

@Slf4j(topic = "c.Main")
public class Main{
    public static void main(String[] args) {
        ExecutorService executor = Executors.newFixedThreadPool(3);

        Thread t1 = new Thread(() ->{
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            log.debug("我是任务");
        });
        executor.execute(t1);
    }
}

         输出结果如下：

5.2 获取结果

                语法如下：

// 提交任务 task，用返回值 Future 获得任务执行结果
<T> Future<T> submit(Callable<T> task);

        测试代码如下：

@Slf4j(topic = "c.Main")
public class Main{
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        ExecutorService executor = Executors.newFixedThreadPool(3);
        Future<String> future = executor.submit(() ->{
            log.debug("running");
            Thread.sleep(1000);
            return "ok";
        });
        log.debug("输出结果为 {}",future.get());
    }
}

         输出结果如下：

5.3 提交所有任务

        语法如下：

// 提交 tasks 中所有任务
<T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks)
    throws InterruptedException;

        测试代码如下：

@Slf4j(topic = "c.Main")
public class Main{
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        ExecutorService executor = Executors.newFixedThreadPool(3);
        List<Future<String>> futures = executor.invokeAll(Arrays.asList(
                () -> {
                    log.debug("begin 1");
                    Thread.sleep(1000);
                    return "1";
                },
                () -> {
                    log.debug("begin 2");
                    Thread.sleep(500);
                    return "2";
                },
                () -> {
                    log.debug("begin 3");
                    Thread.sleep(2000);
                    return "3";
                }
        ));

        for (Future<String> future:futures) {
            log.debug("输出结果为：{}",future.get());
        }
    }
}

         输出结果如下：

5.4 提交所有任务带超时时间

        语法如下：

<T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks,long timeout, TimeUnit unit)
    throws InterruptedException;

        测试代码如下：

@Slf4j(topic = "c.Main")
public class Main{
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        ExecutorService executor = Executors.newFixedThreadPool(3);
        List<Future<String>> futures = executor.invokeAll(Arrays.asList(
                () -> {
                    log.debug("begin 1");
                    Thread.sleep(1000);
                    return "1";
                },
                () -> {
                    log.debug("begin 2");
                    Thread.sleep(500);
                    return "2";
                },
                () -> {
                    log.debug("begin 3");
                    Thread.sleep(2000);
                    return "3";
                }
        ),1l,TimeUnit.SECONDS);

        for (Future<String> future:futures) {
            log.debug("输出结果为：{}",future.get());
        }
    }
}

        输出结果如下：

5.5 先执行返回

        语法如下：

// 提交 tasks 中所有任务，哪个任务先成功执行完毕，返回此任务执行结果，其它任务取消
<T> T invokeAny(Collection<? extends Callable<T>> tasks)
	throws InterruptedException, ExecutionException;

        测试代码如下：

@Slf4j(topic = "c.Main")
public class Main{
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        ExecutorService executor = Executors.newFixedThreadPool(3);
        String str = executor.invokeAny(Arrays.asList(
                () -> {
                    log.debug("begin 1");
                    Thread.sleep(1000);
                    return "1";
                },
                () -> {
                    log.debug("begin 2");
                    Thread.sleep(500);
                    return "2";
                },
                () -> {
                    log.debug("begin 3");
                    Thread.sleep(2000);
                    return "3";
                }
        ));
        log.debug("输出结果为：{}",str);
    }
}

        输出结果如下：

5.6 先执行返回带超时时间

        语法如下：

// 提交 tasks 中所有任务，哪个任务先成功执行完毕，返回此任务执行结果，其它任务取消，带超时时间
<T> T invokeAny(Collection<? extends Callable<T>> tasks,long timeout, TimeUnit unit)
	throws InterruptedException, ExecutionException, TimeoutException;

        测试代码如下：

@Slf4j(topic = "c.Main")
public class Main{
    public static void main(String[] args) throws ExecutionException, InterruptedException, TimeoutException {
        ExecutorService executor = Executors.newFixedThreadPool(3);
        String str = executor.invokeAny(Arrays.asList(
                () -> {
                    log.debug("begin 1");
                    Thread.sleep(2000);
                    return "1";
                },
                () -> {
                    log.debug("begin 2");
                    Thread.sleep(3000);
                    return "2";
                },
                () -> {
                    log.debug("begin 3");
                    Thread.sleep(2000);
                    return "3";
                }
        ),1l,TimeUnit.SECONDS);
        log.debug("输出结果为：{}",str);
    }
}

        输出结果如下：

六、关闭线程池

6.1 shutdown

        可以调用 shutdown() 方法来关闭线程池，调用完该方法之后，线程池不会接收新任务，它会将队列中的任务执行完，且不会阻塞调用线程的执行，测试代码如下：

@Slf4j(topic = "c.Main")
public class Main{
    public static void main(String[] args) throws ExecutionException, InterruptedException, TimeoutException {
        ExecutorService executor = Executors.newFixedThreadPool(3);
        Future<Integer> result1 = executor.submit(() -> {
            log.debug("task 1 running...");
            Thread.sleep(1000);
            log.debug("task 1 finsh...");
            return 1;
        });
        Future<Integer> result2 = executor.submit(() -> {
            log.debug("task 2 running...");
            Thread.sleep(1000);
            log.debug("task 2 finsh...");
            return 2;
        });
        Future<Integer> result3 = executor.submit(() -> {
            log.debug("task 3 running...");
            Thread.sleep(1000);
            log.debug("task 3 finsh...");
            return 3;
        });
        log.debug("shutdown");
        executor.shutdown();
        log.debug("不影响其他线程的执行");

    }
}

        输出结果如下：

6.2 shutdownNow

        可以调用 shutdownNow() 方法来关闭线程池，调用完该方法之后，线程池不会接收新任务，它会将队列中的任务返回，并且用 interrupt 的方式中断正在执行的任务。且不会阻塞调用线程的执行，测试代码如下：

@Slf4j(topic = "c.Main")
public class Main{
    public static void main(String[] args) throws ExecutionException, InterruptedException, TimeoutException {
        ExecutorService executor = Executors.newFixedThreadPool(2);
        Future<Integer> result1 = executor.submit(() -> {
            log.debug("task 1 running...");
            Thread.sleep(1000);
            log.debug("task 1 finsh...");
            return 1;
        });
        Future<Integer> result2 = executor.submit(() -> {
            log.debug("task 2 running...");
            Thread.sleep(1000);
            log.debug("task 2 finsh...");
            return 2;
        });
        Future<Integer> result3 = executor.submit(() -> {
            log.debug("task 3 running...");
            Thread.sleep(1000);
            log.debug("task 3 finsh...");
            return 3;
        });
        log.debug("shutdown");
        List<Runnable> r = executor.shutdownNow();
        log.debug("other....{}",r);
    }
}

        输出结果如下：

七、核心线程数量

        如果线程池中核心线程的数量过小会导致程序不能充分地利用系统资源、容易导致饥饿；过大会导致更多的线程上下文切换，占用更多内存。

7.1 CPU 密集型运算

        cpu 密集型指的就是运算比较多的情况，通常采用 cpu 核数 + 1 能够实现最优的 CPU 利用率，+1 是保证当线程由于页缺失故障（操作系统）或其它原因导致暂停时，额外的这个线程就能顶上去，保证 CPU 时钟周期不被浪费。

7.2 I/O 密集型运算

        CPU 不总是处于繁忙状态，例如，当你执行业务计算时，这时候会使用 CPU 资源，但当你执行 I/O 操作时、远程 RPC 调用时，包括进行数据库操作时，这时候 CPU 就闲下来了，你可以利用多线程提高它的利用率。

        经验公式如下：

线程数 = 核数 * 期望 CPU 利用率 * 总时间(CPU计算时间+等待时间) / CPU 计算时间

        例如 4 核 CPU 计算时间是 50% ，其它等待时间是 50%，期望 cpu 被 100% 利用，套用公式：

4 * 100% * 100% / 50% = 8

        例如 4 核 CPU 计算时间是 10% ，其它等待时间是 90%，期望 cpu 被 100% 利用，套用公式：

4 * 100% * 100% / 10% = 40

八、任务调度线程池

8.1 Timer 缺点

        在任务调度线程池功能加入之前，可以使用 java.util.Timer 来实现定时功能，Timer 的优点在于简单易用，但由于所有任务都是由同一个线程来调度，因此所有任务都是串行执行的，同一时间只能有一个任务在执行，前一个任务的延迟或异常都将会影响到之后的任务。如下代码：

@Slf4j(topic = "c.Main")
public class Main {
    public static void main(String[] args) {
        Timer timer = new Timer();
        TimerTask task1 = new TimerTask() {
            @Override
            public void run() {
                log.debug("task 1");
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        };
        TimerTask task2 = new TimerTask() {
            @Override
            public void run() {
                log.debug("task 2");
            }
        };
        // 使用 timer 添加两个任务，希望它们都在 1s 后执行
        // 但由于 timer 内只有一个线程来顺序执行队列中的任务，因此『任务1』的延时，影响了『任务2』的执行
        log.debug("start...");
        timer.schedule(task1, 1000);
        timer.schedule(task2, 1000);
    }
}

        输出结果如下：

8.2 ScheduledExecutorService

        此时我们就可以使用 ScheduledExecutorService 来实现上述的功能，代码如下：

@Slf4j(topic = "c.Main")
public class Main {
    public static void main(String[] args) {
        ScheduledExecutorService executor = Executors.newScheduledThreadPool(2);
        // 添加两个任务，希望它们都在 1s 后执行
        executor.schedule(() -> {
            System.out.println("任务1，执行时间：" + new Date());
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
            }
        }, 1000, TimeUnit.MILLISECONDS);

        executor.schedule(() -> {
            System.out.println("任务2，执行时间：" + new Date());
        }, 1000, TimeUnit.MILLISECONDS);
    }
}

        可以看到，这两个任务都是在 1s 之后同时执行的。

8.3 scheduleAtFixedRate

        如果想以固定的速率来执行任务，我们就可以使用 scheduleAtFixedRate ，测试代码如下：

@Slf4j(topic = "c.Main")
public class Main {
    public static void main(String[] args) {
        ScheduledExecutorService pool = Executors.newScheduledThreadPool(1);
        log.debug("start...");
        pool.scheduleAtFixedRate(() -> {
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            log.debug("running...");
        }, 1, 1, TimeUnit.SECONDS);
    }
}

        输出结果如下，可以看到虽然我们设置了 1s 执行一次，但是任务里面执行了 2s，最终的效果就是 2s 之后才执行一次调度任务，保证了任务的正常执行。

8.4 scheduleWithFixedDelay

        这个线程池也是以固定的速率来执行任务，它和 scheduleAtFixedRate 的区别是，它需要等到任务执行完毕后，再等待固定的时间再去执行任务，如下代码：

@Slf4j(topic = "c.Main")
public class Main {
    public static void main(String[] args) {
        ScheduledExecutorService pool = Executors.newScheduledThreadPool(1);
        log.debug("start...");
        pool.scheduleWithFixedDelay(() -> {
            log.debug("running...");
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }, 1, 1, TimeUnit.SECONDS);
    }
}

        输出结果如下，可以看到，任务执行 2s，延迟 1s，最终任务 3s 之后才开始调度执行。

8.5 定时调度应用

        如何让每周四 18:00:00 定时执行任务？实现代码如下：

@Slf4j(topic = "c.Main")
public class Main {
    public static void main(String[] args) {
        // 获得当前时间
        LocalDateTime now = LocalDateTime.now();
        // 获取本周四 18:00:00.000
        LocalDateTime thursday =
                now.with(DayOfWeek.THURSDAY).withHour(18).withMinute(0).withSecond(0).withNano(0);
        // 如果当前时间已经超过 本周四 18:00:00.000， 那么找下周四 18:00:00.000
        if (now.compareTo(thursday) >= 0) {
            thursday = thursday.plusWeeks(1);
        }
        // 计算时间差，即延时执行时间
        long initialDelay = Duration.between(now, thursday).toMillis();
        // 计算间隔时间，即 1 周的毫秒值
        long oneWeek = 7 * 24 * 3600 * 1000;
        ScheduledExecutorService executor = Executors.newScheduledThreadPool(2);
        System.out.println("开始时间：" + new Date());
        executor.scheduleAtFixedRate(() -> {
            System.out.println("执行时间：" + new Date());
        }, initialDelay, oneWeek, TimeUnit.MILLISECONDS);
    }
}

九、Fork/Join 线程池

9.1 概念

        Fork/Join 是 JDK 1.7 加入的新的线程池实现，它体现的是一种分治思想，适用于能够进行任务拆分的 cpu 密集型运算。

        所谓的任务拆分，是将一个大任务拆分为算法上相同的小任务，直至不能拆分可以直接求解。跟递归相关的一些计算，如归并排序、斐波那契数列、都可以用分治思想进行求解。

        Fork/Join 在分治的基础上加入了多线程，可以把每个任务的分解和合并交给不同的线程来完成，进一步提升了运算效率。

        Fork/Join 默认会创建与 cpu 核心数大小相同的线程池。

9.2 使用

        提交给 Fork/Join 线程池的任务需要继承 RecursiveTask（有返回值）或 RecursiveAction（没有返回值），例如下面定义了一个对 1~n 之间的整数求和的任务，如下代码：

@Slf4j(topic = "c.AddTask")
class AddTask1 extends RecursiveTask<Integer> {
    int n;

    public AddTask1(int n) {
        this.n = n;
    }

    @Override
    public String toString() {
        return "{" + n + '}';
    }

    @Override
    protected Integer compute() {
        // 如果 n 已经为 1，可以求得结果了
        if (n == 1) {
            log.debug("join() {}", n);
            return n;
        }

        // 将任务进行拆分(fork)
        AddTask1 t1 = new AddTask1(n - 1);
        t1.fork();
        log.debug("fork() {} + {}", n, t1);

        // 合并(join)结果
        int result = n + t1.join();
        log.debug("join() {} + {} = {}", n, t1, result);
        return result;
    }

    public static void main(String[] args) {
        ForkJoinPool pool = new ForkJoinPool(4);
        System.out.println(pool.invoke(new AddTask1(5)));
    }
}

        输出结果如下所示：

快乐的小三菊
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
五种线程池的分类和作用
weixin_30780649的博客
07-17 1549
1、newCachedThreadPool 作用：创建一个可根据需要创建新线程的线程池，但是在以前构造的线程可用时将重用它们，并在需要时使用提供的 ThreadFactory 创建新线程。 特征：（1）线程池中数量没有固定，可达到最大值（Interger. MAX_VALUE）（2）线程池中的线程可进行缓存重复利用和回收（回收默认时间为1分钟）（3）当线程池中，没有可用线程，会重新创建一...
Java并发编程：线程池的使用 - 平凡希 - 博客园1
08-04
Java并发编程中的线程池是提高系统效率的关键工具，它解决了频繁创建和销毁线程的问题。线程池通过复用已存在的线程来处理任务，从而避免了每次任务执行完毕后销毁线程的开销。在Java中，线程池的核心实现是`java....
线程池（知识点）
我的java空间
10-25 109
[b][size=small;]固定线程池[/size][/b] [size=small;]public static executorservice newfixdthreadpool(int size);[/size] [size=small;]此方法产生一个具有固定大小的线程池、如果有线程异常中止，将产生新的线程来替代他，参数size用来给出线程池的大小。[/size] [size=...
线程池知识点
qq_48689310的博客
02-27 168
自定义线程池就需要我们自己配置最大线程数maximumPoolSize，为了高效的并发运行，当。CPU密集的意思是该任务需要大量的运算，而没有阻塞，CPU一直全速运行。务只有在真正的多核CPU上才可能得到加速(通过多线程)，而在单核CPU上，无论你开几。I0密集型，即该任务需要大量的IO，即大量的阻塞。在单线程上运行I0密集型的任务会导。因为频繁的开启线程或者停止线程，线程需要从新被cpu从就绪到运行状态调度，需要发生。线程池和数据库连接池非常类似，可以统一管理和维护线程，减少没有必要的开销。
23 高并发编程和线程池
08-07
23 高并发编程和线程池，教程视频：java中高并发编程和线程池
Java – 并发编程 – 线程池
01-21
我们创建的线程在运行结束后都会被虚拟机销毁，如果线程数量多的话，频繁的创建和销毁线程会大大浪费时间和效率，更重要的是浪费内存，线程池可以让线程运行后不立刻销毁，而是让线程重复使用，继续执行其他任务 ...
并发容器和线程池，java并发编程3
最新发布
04-29
`Future`接口提供了获取异步计算结果的能力，它是Java并发编程中重要的API之一。 ##### 3.1 FutureTask `FutureTask`是`Future`接口的一个具体实现，它可以包装一个`Runnable`或`Callable`对象，并允许用户获取...
java并发编程_线程池的使用方法(详解)
08-30
java并发编程_线程池的使用方法 java并发编程中，线程池是一种非常重要的概念，它可以帮助我们更好地管理线程，提高程序的性能和可扩展性。下面我们将详细介绍java线程池的使用方法。 一、任务和执行策略之间的...
线程池相关知识点
小金莫慌
05-29 216
参考路线：https://blog.csdn.net/pfnie/article/details/52757002 首先明确一点： 线程池不允许使用 Executors 去创建,而是通过 ThreadPoolExecutor 的方式,这样的处理方式让写的同学更加明确线程池的运行规则,规避资源耗尽的风险。 Executors 返回的线程池对象的弊端如下: 1)FixedThreadPoo...
线程池知识点--＞线程池的分类、创建、参数理解、执行流程及状态等
weixin_54505261的博客
07-17 177
线程数固定的线程池，线程池中的线程数量固定，不会随着任务的增加而增加，也不会随着任务的减少而减少。线程数根据任务动态调整的线程池，线程池中的线程数量可以根据需要进行动态调整，如果有空闲线程可用，则会重用空闲线程，如果没有可用线程，则会创建新的线程。4.完成任务：线程执行完任务后，会返回执行结果（如果任务是Callable类型），然后线程会继续从任务队列中取出任务执行，直到任务队列为空。：能实现定时、周期性任务的线程池，可以定时执行任务的线程池，可以指定任务的延迟时间和执行周期。
线程池基本知识点
qq_43686030的博客
01-11 398
线程池化的好处 首先，通过重复利用已创建的线程降低线程创建和销毁造成的消耗。 第二，提高响应速度，任务到达时，无需等待线程的创建，线程池中的核心线程可以立马执行。 第三，通过对线程池的管理，可以保证对线程的有效操作。 线程池的工作流程 当任务来临时，首先判断核心线程数是否已满，未满则创建线程执行任务(corePoolSize) 若核心线程数已达最大值，判断队列是否已满，若未满则加入队列中(workQueue) 若队列已满，判断最大线程数是否已达最大值，若未满创建线程执行任务(maximumPoolSize)
线程池
after_17的博客
03-23 127
目录概念优点流程 概念 一种线程使用模式，线程过多会带来调度开销，进而影响缓存局部性和整体性能。而线程池维护着多个线程，等待着监督管理者分配可并发执行的任务。这避免了在处理短时间任务时创建与销毁线程的代价。简单来说，线程都放在一个池里，每次使用都从池里获取，用完后归还到池中。 优点 提⾼线程的利⽤率 提⾼响应速度 便于统⼀管理线程对象 可控制最⼤并发数 流程 线程池初始化会对以下参数进行设置 corePoolSize：核⼼池的⼤⼩ maximumPoolSize：线程池的最⼤容量 keepAliveTi
关于线程池的知识点整理
Anonym的笔记整理
03-02 316
线程池 线程 &amp; 进程 概念 进程是操作系统进行资源分配和调度的一个独立单元，而线程是CPU调度的基本单元。 关联与区别 同一个进程可以包括多个线程，并且线程共享整个进程的资源（寄存器、堆栈、上下文），一个进程至少包括一个线程。 线程是轻量级的进程，它的创建和销毁所需要的时间比进程要小很多，并且所有操作系统的执行功能都是创建线程去执行的。 线程中执行一般都要进行互斥或同...
线程池的相关知识点(三大方法，七大参数，四种拒绝策略)
java_cG的博客
02-14 236
多线程编码方式： class MyTask implements Runnable{ public void run(){} } public class Test{ public static void main(String[] args){ MyTask task = new MyTask(); Thread thread = new Thre...
java线程池知识点
Enzo的探索之路
06-30 1241
线程池的优势 合理的使用线程池会带来三个好处： 降低资源的消耗。通过重复利用已创建的线程降低线程创建和销毁的开销； 提高响应速度。当任务到达时，任务不需要等到线程创建就能直接执行； 提高线程的可管理性。线程是稀缺资源，使用线程池可以进行统一分配、调优和监控。 工作原理 线程池保存一定量的线程，当有任务提交到线程池时，线程池若还没有达到最大线程数，则创建一个线程执行任务。若所有的线程都处于工作状...
线程池基本知识点总结
xhxn_的博客
07-19 58
线程池是一种利用池化技术思想来实现的线程管理技术，主要是为了复用线程、便利地管理线程和任务、并将线程的创建和任务的执行解耦开来。
线程池基本知识
Android_la的博客
09-24 577
本篇博客旨在对线程池的各个参数有一个基本的全局了解，基本不涉及案例demo代码。不必背诵这些知识点，有不懂之处需要上下文反复阅读，反复思考。本文描述线程池是JDK1.8中提供的类。本文基本都是从Java线程池实现原理及其在美团业务中的实践搬来的，有需要了解更详细的信息可以直接看它。
python线程池回调函数_第11天续，Python并发编程之线程池/进程池
05-31
好的，关于线程池回调函数，可以在提交任务时指定回调函数，当任务完成时，线程池会自动调用回调函数，以通知任务已经完成。 在Python中，可以使用concurrent.futures模块中的ThreadPoolExecutor来创建线程池，通过...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

快乐的小三菊

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值