<i id='vftU2'><tr id='vftU2'><dt id='vftU2'><q id='vftU2'><span id='vftU2'><b id='vftU2'><form id='vftU2'><ins id='vftU2'></ins><ul id='vftU2'></ul><sub id='vftU2'></sub></form><legend id='vftU2'></legend><bdo id='vftU2'><pre id='vftU2'><center id='vftU2'></center></pre></bdo></b><th id='vftU2'></th></span></q></dt></tr></i><div id='vftU2'><tfoot id='vftU2'></tfoot><dl id='vftU2'><fieldset id='vftU2'></fieldset></dl></div>

    1. <tfoot id='vftU2'></tfoot>
    2. <small id='vftU2'></small><noframes id='vftU2'>

    3. <legend id='vftU2'><style id='vftU2'><dir id='vftU2'><q id='vftU2'></q></dir></style></legend>
        <bdo id='vftU2'></bdo><ul id='vftU2'></ul>

      Java线程池详细解读

      时间:2023-12-11
    4. <tfoot id='VW9kI'></tfoot>

        <tbody id='VW9kI'></tbody>

      • <bdo id='VW9kI'></bdo><ul id='VW9kI'></ul>
          <i id='VW9kI'><tr id='VW9kI'><dt id='VW9kI'><q id='VW9kI'><span id='VW9kI'><b id='VW9kI'><form id='VW9kI'><ins id='VW9kI'></ins><ul id='VW9kI'></ul><sub id='VW9kI'></sub></form><legend id='VW9kI'></legend><bdo id='VW9kI'><pre id='VW9kI'><center id='VW9kI'></center></pre></bdo></b><th id='VW9kI'></th></span></q></dt></tr></i><div id='VW9kI'><tfoot id='VW9kI'></tfoot><dl id='VW9kI'><fieldset id='VW9kI'></fieldset></dl></div>
            <legend id='VW9kI'><style id='VW9kI'><dir id='VW9kI'><q id='VW9kI'></q></dir></style></legend>

                <small id='VW9kI'></small><noframes id='VW9kI'>

                Java线程池详细解读

                什么是线程池?

                线程池是一种用于多线程管理的机制,它可以有效管理将要执行的任务,减轻了创建和销毁线程的负担。通过复用现有线程,避免了大量线程创建和销毁过程中的开销,从而提高了应用程序的性能和可伸缩性。

                线程池的优势

                线程池的优势主要体现在以下几个方面:

                • 更好的利用 CPU 资源和减少上下文切换的时间开销。
                • 可以根据需要创建和回收线程,从而避免了线程创建和销毁的开销。
                • 能够控制线程的数量和执行优先级,防止过多的请求导致程序崩溃。
                • 能够通过设置队列等待机制,使得任务顺序执行进而避免线程竞争。

                线程池的实现方式

                在 Java 中,可以使用 java.util.concurrent 包中的线程池来实现线程管理。常用的线程池类型有以下四种:

                1. FixedThreadPool:该线程池类型的核心线程数是固定的,同时也允许在池中创建的线程数量保持不变。一般情况下它使用无界队列,即可以放入无限多的任务。
                2. CachedThreadPool:该线程池类型的核心线程数是 0,为非固定值。当池中线程数量不够用时,会创建新的线程,而池中线程数量缩减时,会回收后面的线程。此种类型线程池在取得一个工作线程时总是先尝试复用之前的线程。
                3. SingleThreadExecutor:该线程池类型只有一个线程,每提交一个任务就会产生一个任务。
                4. ScheduledThreadPool:该线程池支持延迟执行和定时执行的任务。

                线程池的实现过程

                使用线程池的主要过程是:

                1. 创建一个线程池对象。
                2. 创建任务并提交到线程池中执行。
                3. 等待任务执行完成,关闭线程池。

                它的基本代码如下所示:

                // 创建一个大小固定为 5 的线程池
                ExecutorService executorService = Executors.newFixedThreadPool(5);
                
                // 创建任务并提交到线程池中执行
                executorService.execute(new Runnable() {
                    @Override
                    public void run() {
                        // 业务处理逻辑
                    }
                });
                
                // 等待任务执行完成,关闭线程池
                executorService.shutdown();
                

                示例一:使用 FixedThreadPool

                下面是一个使用 FixedThreadPool 的示例代码:

                // 创建一个核心线程数为 5 的固定线程池
                ExecutorService fixedThreadPool = Executors.newFixedThreadPool(5);
                
                // 提交至少 10 个任务到线程池中
                for (int i = 1; i <= 10; i++) {
                    fixedThreadPool.execute(new Task(i));
                }
                
                // 关闭线程池
                fixedThreadPool.shutdown();
                
                class Task implements Runnable {
                    private int taskId;
                
                    public Task(int taskId) {
                        this.taskId = taskId;
                    }
                
                    @Override
                    public void run() {
                        System.out.println(Thread.currentThread().getName() + " 执行任务 " + taskId);
                    }
                }
                

                在该示例中,线程池的核心线程数是 5,然后将 10 个任务添加到线程池中进行执行。程序的执行结果为:

                pool-1-thread-2 执行任务 2
                pool-1-thread-1 执行任务 1
                pool-1-thread-3 执行任务 3
                pool-1-thread-4 执行任务 4
                pool-1-thread-5 执行任务 5
                pool-1-thread-5 执行任务 6
                pool-1-thread-2 执行任务 7
                pool-1-thread-4 执行任务 8
                pool-1-thread-1 执行任务 9
                pool-1-thread-3 执行任务 10
                

                示例二:使用 ScheduledThreadPool

                下面是一个使用 ScheduledThreadPool 的示例代码:

                // 创建一个大小固定为 5 的线程池
                ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(5);
                
                // 延迟 1 秒后执行任务
                scheduledExecutorService.schedule(new Task(), 1L, TimeUnit.SECONDS);
                
                // 延迟 3 秒后执行任务
                scheduledExecutorService.schedule(new Task(), 3L, TimeUnit.SECONDS);
                
                // 每 1 秒执行一次任务
                scheduledExecutorService.scheduleAtFixedRate(new Task(), 0L, 1L, TimeUnit.SECONDS);
                
                // 每 3 秒执行一次任务
                scheduledExecutorService.scheduleWithFixedDelay(new Task(), 0L, 3L, TimeUnit.SECONDS);
                
                // 关闭线程池
                scheduledExecutorService.shutdown();
                
                class Task implements Runnable {
                    @Override
                    public void run() {
                        System.out.println("当前时间:" + new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
                    }
                }
                

                在该示例中,线程池的核心线程数是 5,然后分别在 1s 和 3s 后执行任务,每隔 1s 和 3s 执行一次任务。程序的执行结果为:

                当前时间:2021-11-06 16:06:16
                当前时间:2021-11-06 16:06:17
                当前时间:2021-11-06 16:06:17
                当前时间:2021-11-06 16:06:18
                当前时间:2021-11-06 16:06:18
                当前时间:2021-11-06 16:06:19
                当前时间:2021-11-06 16:06:19
                当前时间:2021-11-06 16:06:20
                当前时间:2021-11-06 16:06:20
                当前时间:2021-11-06 16:06:21
                
                上一篇:4个Java8中你需要知道的函数式接口分享 下一篇:Java转JSON串的几种方式

                相关文章

                <i id='8agsx'><tr id='8agsx'><dt id='8agsx'><q id='8agsx'><span id='8agsx'><b id='8agsx'><form id='8agsx'><ins id='8agsx'></ins><ul id='8agsx'></ul><sub id='8agsx'></sub></form><legend id='8agsx'></legend><bdo id='8agsx'><pre id='8agsx'><center id='8agsx'></center></pre></bdo></b><th id='8agsx'></th></span></q></dt></tr></i><div id='8agsx'><tfoot id='8agsx'></tfoot><dl id='8agsx'><fieldset id='8agsx'></fieldset></dl></div>
                    <tfoot id='8agsx'></tfoot>
                      <bdo id='8agsx'></bdo><ul id='8agsx'></ul>

                    <small id='8agsx'></small><noframes id='8agsx'>

                    <legend id='8agsx'><style id='8agsx'><dir id='8agsx'><q id='8agsx'></q></dir></style></legend>