java 线程池的使用及原理（一）：线程池的使用

最新推荐文章于 2024-07-13 22:56:10 发布
最新推荐文章于 2024-07-13 22:56:10 发布
阅读量283 收藏
点赞数
分类专栏： java 文章标签： 多线程 java 并发编程 thread 队列
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44245828/article/details/109465881
版权

大家在一开始接触多线程的时候，毫无疑问是用Thread的start()来创建启动一个线程。事实上，线程的创建与销毁是非常消耗时间与系统资源的，甚至比实际需求的消耗还要多。

那么问题来了，我应该怎么正确的使用多线程呢？
java.util.concurrent 包下的 Executors 可以帮我们创建一个线程池，只需传入相应的参数即可。线程池的原理其实就是对多线程的一个管理，为了实现异步机制的一种方法，其实就是多个线程执行多个任务，任务执行完毕，释放对线程的使用权，达成线程复用的效果。

线程池的使用

  • 先会用，后看原理，是我不知道哪里听来的道理
  • java 为我们提供了 5 种类型的线程池：newSingleThreadExecutor、newFixedThreadPool、newCachedThreadPool、newScheduledThreadPool、newWorkStealingPool

1、newSingleThreadExecutor

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

public class NewSingleThreadExecutorTest {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newSingleThreadExecutor();
        for(int i = 0; i < 5; i++) {
            executorService.execute(() -> {
                System.out.println("当前执行线程是 + \t" + Thread.currentThread().getName());
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
        }
        executorService.shutdown();
    }
}
  • 可以看到，一直是同一个线程在执行
    在这里插入图片描述

2、newFixedThreadPool

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

public class NewFixedThreadPoolTest {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(3);
        for(int i = 0; i < 9; i++) {
            executorService.execute(() -> {
                System.out.println("当前执行线程是 + \t" + Thread.currentThread().getName());
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
        }
        executorService.shutdown();
    }
}
  • 三个线程在固定切换
    在这里插入图片描述

3、newCachedThreadPool

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

public class NewCachedThreadPoolTest {
    public static void main(String[] args) throws InterruptedException {
        ExecutorService executorService = Executors.newCachedThreadPool();
        for(int i = 0; i < 5; i++) {
            executorService.execute(() -> {
                System.out.println("当前执行线程是 + \t" + Thread.currentThread().getName());
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
        }
        Thread.sleep(10000);
        System.out.println("================ Cache 复用 ================");
        for(int i = 0; i < 5; i++) {
            executorService.execute(() -> {
                System.out.println("当前执行线程是 + \t" + Thread.currentThread().getName());
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
        }

        executorService.shutdown();
    }
}
  • 需要多少，创建多少，一定时间内可以复用
    在这里插入图片描述

4、newScheduledThreadPool

  • 周期性的执行任务，那么会存在一个问题，间隔时间与任务执行时间
  • scheduleAtFixedRate 当任务执行时间大于间隔时间时，会立刻执行。简单来说，我的间隔时间其实是包含任务执行时间
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class NewScheduledThreadPoolTest {
    public static void main(String[] args) throws InterruptedException {
        ScheduledExecutorService executorService = Executors.newScheduledThreadPool(5);
        executorService.scheduleAtFixedRate(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "\t " + "每2秒执行一次");
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(System.currentTimeMillis());
            }
        }, 1, 2, TimeUnit.SECONDS);
//        executorService.shutdown();
    }
}
  • scheduleWithFixedDelay：不管任务执行时间多久，我只管任务与任务的间隔时间正确。简单来说，我的间隔时间其实是不包含任务执行时间
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class NewScheduledThreadPoolTest {
    public static void main(String[] args) throws InterruptedException {
        ScheduledExecutorService executorService = Executors.newScheduledThreadPool(5);
        executorService.scheduleWithFixedDelay(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "\t " + "每2秒执行一次");
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(System.currentTimeMillis());
            }
        }, 1, 2, TimeUnit.SECONDS);
        // executorService.shutdown();
    }
}

5、newWorkStealingPool

  • 多个任务分成多个队列完成
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class NewWorkStealingPoolTest {
    private static final int threads = 10;
    public static void main(String[] args) throws InterruptedException {
        // 用于计数线程是否执行完成
        CountDownLatch countDownLatch = new CountDownLatch(threads);
        System.out.println("---- start ----");
        ExecutorService executorService = Executors.newWorkStealingPool(3);
        for (int i = 0; i < threads; i++) {
            executorService.execute(() -> {
                try {
                    Thread.sleep(1000);
                    System.out.println(Thread.currentThread().getName());
                } catch (Exception e) {
                    System.out.println(e);
                } finally {
                    countDownLatch.countDown();
                }
            });
        }
        countDownLatch.await();
        System.out.println("---- end ----");
    }
}

在这里插入图片描述

总结

  • newSingleThreadExecutor：单一线程来执行任务，保证任务是按照指定顺序执行；
  • newFixedThreadPool：创建固定大小的线程池，可控制线程最大的并发数，超出的线程会在队列中等待；
  • newCachedThreadPool：无限扩大的线程池，需要就创建，一定时间后自动回收；
  • newScheduledThreadPool：可以延时启动，执行间隔时间相同的任务；
  • newWorkStealingPool：将任务分解成多个任务队列，缓冲线程池的压力；

execute() 和 submit() 的区别

  • execute() 是 void 方法，没有返回值
  • submit 有三个重载方法
    • public Future<?> submit(Runnable task); // 不带返回值使用
    • public Future submit(Runnable task, T result); // 在调用方法时，确定返回值
    • public Future submit(Callable task); // 在Callable内返回需要的值
public class ExecuteAndSubmit {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        ThreadPoolExecutor threadPool = new ThreadPoolExecutor(2, 5,
                0L, TimeUnit.MILLISECONDS,
                new LinkedBlockingQueue<Runnable>(1000));

        threadPool.execute(() -> {
            System.out.println("我是 execute，我没有返回值，需要返回值请使用 submit");
        });

        Future<?> submit2 = threadPool.submit(() -> {
            System.out.println("我是submit，但传入的是 (Runnable)");
        });
        System.out.println("我是没有类型的返回值" + submit2.get());

        Future<Integer> submit = threadPool.submit(() -> {
            System.out.println("我是submit，但传入的是 (Callable)");
            return 10;
        });
        System.out.println("Callable 返回值" + submit.get());

        Future<Integer> submit1 = threadPool.submit(() -> {
            System.out.println("我是submit，但传入的是 (Runnable，T)");
        }, 1000);
        System.out.println("我是submit，但传入的是 (Runnable)，但同时传入了一个返回值" + submit1.get());

        threadPool.shutdown();
    }
}

在这里插入图片描述

线程池方法使用示例

  • 这里我们使用自定义的线程池
  • allowCoreThreadTimeOut：允许核心线程超时，即线程池不调用shutdown也可以自动关闭
  • prestartCoreThread：核心线程预创建，true 表示创建成功，这里只会预创建一个
  • prestartAllCoreThreads：预创建设置的核心线程，返回预创建的个数
  • getActiveCount：获取当前活跃的线程个数
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class InstanceMethodsTest {
    public static void main(String[] args) {
        ThreadPoolExecutor threadPool = new ThreadPoolExecutor(3, 10,
                1L, TimeUnit.MILLISECONDS,
                new LinkedBlockingQueue<Runnable>(2));
        int activeCount = threadPool.getActiveCount();
        System.out.println("刚创建完线程池的 activeCount" + activeCount);
        System.out.println("============== 开始预创建线程 ==============");
        /* 线程池核心线程允许超时设置 */
        threadPool.allowCoreThreadTimeOut(true);
        boolean flag = threadPool.prestartCoreThread();
        System.out.println("prestartCoreThread 预创建单个线程是否成功" + flag);
        int prestartAllCoreThreads = threadPool.prestartAllCoreThreads();
        System.out.println("prestartAllCoreThreads: 创建全部核心线程" + prestartAllCoreThreads);
        int activeCount1 = threadPool.getActiveCount();
        System.out.println("preCoreThread预创建核心线程的 activeCount1: " + activeCount1);


        System.out.println("============== 核心数已满，再来预创建线程 ==============");
        boolean flag1 = threadPool.prestartCoreThread();
        System.out.println("prestartCoreThread 预创建单个线程是否成功" + flag1);
        int prestartAllCoreThreads1 = threadPool.prestartAllCoreThreads();
        System.out.println("prestartAllCoreThreads: " + prestartAllCoreThreads1);
        int activeCount2 = threadPool.getActiveCount();
        System.out.println("preCoreThread预创建核心线程的 activeCount1: " + activeCount2);
    }
}

在这里插入图片描述

  • 监控线程池状态
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class InstanceMethodsTest01 {
    public static void main(String[] args) throws InterruptedException {
        ThreadPoolExecutor threadPool = new ThreadPoolExecutor(50, 100,
                1L, TimeUnit.MILLISECONDS,
                new LinkedBlockingQueue<Runnable>(1000));
        for(int i = 1; i <= 1000; i++) {
            threadPool.execute(() -> {
                try {
                    Thread.sleep(1000);
                    System.out.print("0");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
        }
        while (true) {
            System.out.println();

            int queueSize = threadPool.getQueue().size();
            System.out.println("当前排队线程数getQueue：" + queueSize);

            int activeCount = threadPool.getActiveCount();
            System.out.println("当前活动线程数getActiveCount：" + activeCount);


            long completedTaskCount = threadPool.getCompletedTaskCount();
            System.out.println("执行完成线程数getCompletedTaskCount：" + completedTaskCount);

            long taskCount = threadPool.getTaskCount();
            System.out.println("总线程数getTaskCount：" + taskCount);

            Thread.sleep(3000);
        }

    }
}
  • 输出如下：
    • getCompletedTaskCount：获取已完成任务大致总数， 不一定是实时，因为操作完成，记录也需要时间
当前排队线程数getQueue：950
当前活动线程数getActiveCount：50
执行完成线程数getCompletedTaskCount：0
总线程数getTaskCount：1000
000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
0当前排队线程数getQueue：812
当前活动线程数getActiveCount：50
执行完成线程数getCompletedTaskCount：139
总线程数getTaskCount：1000
00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
当前排队线程数getQueue：695
当前活动线程数getActiveCount：50
执行完成线程数getCompletedTaskCount：255
总线程数getTaskCount：1000
000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
当前排队线程数getQueue：545
当前活动线程数getActiveCount：50
执行完成线程数getCompletedTaskCount：405
总线程数getTaskCount：1000
000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
当前排队线程数getQueue：395
当前活动线程数getActiveCount：50
执行完成线程数getCompletedTaskCount：555
总线程数getTaskCount：1000
000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
当前排队线程数getQueue：245
当前活动线程数getActiveCount：50
执行完成线程数getCompletedTaskCount：705
总线程数getTaskCount：1000
000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
当前排队线程数getQueue：95
当前活动线程数getActiveCount：50
执行完成线程数getCompletedTaskCount：855
总线程数getTaskCount：1000
0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
当前排队线程数getQueue：0
当前活动线程数getActiveCount：0
执行完成线程数getCompletedTaskCount：1000
总线程数getTaskCount：1000

当前排队线程数getQueue：0
当前活动线程数getActiveCount：0
执行完成线程数getCompletedTaskCount：1000
总线程数getTaskCount：1000

当前排队线程数getQueue：0
当前活动线程数getActiveCount：0
执行完成线程数getCompletedTaskCount：1000
总线程数getTaskCount：1000

Process finished with exit code -1
cerish404
关注
专栏目录
pdf 深入理解kotlin协程_Kotlin协程实现原理:挂起与恢复
weixin_39964899的博客
12-03 417
今天我们来聊聊Kotlin的协程Coroutine。如果你还没有接触过协程，推荐你先阅读这篇入门级文章What? 你还不知道Kotlin Coroutine?如果你已经接触过协程，但对协程的原理存在疑惑，那么在阅读本篇文章之前推荐你先阅读下面的文章，这样能让你更全面更顺畅的理解这篇文章。Kotlin协程实现原理:Suspend&CoroutineContextKotlin协程实现原理:Co...
创建线程池的正确姿势，请给它指定一个有意义的名字
qianlia的博客
05-11 4561
为什么我们创建线程或者线程池的时候，需要指定有意义的线程名称？ 最终目的是为了方便回溯。 我们在日常开发中，一个项目中会创建很多个线程池用来资源隔离，但是如果我们没有一个好的命名的话，出问题的时候就会难以定位。 public class Demo5 { ​ public static void main( String[] args ) throws IOException { new Thread(()->{ System.out.println(&q
pdf 深入理解kotlin协程_《深入理解Kotlin协程》,9787111655916
weixin_28940939的博客
01-17 1607
《深入理解Kotlin协程》内容简介：这是一部从工作机制、实现原理、应用场景、使用方法、实践技巧、标准库、框架、应用案例等多个维度全面讲解Kotlin协程的专著，它同时提供了多语言视角，亦可通过本书了解其他语言的协程。本书作者是腾讯的的不错工程师，是靠前Kotlin领域的先驱者和布道者，不仅在工程实践领域积累了丰富的经验，而且在Kotlin开发者社群里有广泛的影响力和号召力。全书共9章：章从协程的...
Java 线程池详解
最新发布
qq_41591215的博客
07-13 3470
线程池是一组已经初始化并等待执行任务的线程集合。通过使用线程池，我们可以避免频繁地创建和销毁线程，从而节省资源和减少系统开销。线程池的核心思想是通过复用线程来提高性能。
线程池命名
tszc95的博客
04-28 499
初始化线程池的时候需要显示命名（设置线程池名称前缀），有利于定位问题。这样的，没有业务含义，不利于我们定位问题。默认情况下创建的线程名字类似。
安卓悬浮窗怎么盖在状态栏_引擎盖下的悬浮修饰符
weixin_26727575的博客
09-25 501
安卓悬浮窗怎么盖在状态栏Kotlin coroutines introduced the suspend modifier in our daily life as Android developers. Are you curious to see what’s happening under the hood? How is the compiler transforming the code...
Java线程池使用与原理详解
08-29
Java线程池使用与原理详解 Java线程池是Java语言中的一种高级机制，用于管理和复用线程，以提高程序的执行效率和性能。本文将详细介绍Java线程池的使用和原理，包括线程池的概念、线程池的优点、线程池的创建、...
Java常用线程池原理及使用方法解析
08-18
Java线程池是一种高效管理线程的工具，它允许开发者预先创建一组线程，当需要执行新任务时，线程池会从池中选择一个空闲线程来执行任务，而不是每次都创建新的线程。线程池的使用有助于减少线程创建和销毁的开销，...
Java线程池ThreadPoolExecutor原理及使用实例
08-19
Java线程池ThreadPoolExecutor原理及使用实例 Java线程池ThreadPoolExecutor是Java并发编程中的一种基本机制，主要用于管理和执行任务的线程池。下面对其原理和使用实例进行详细介绍。 线程池概述 线程池是一个...
JAVA线程池原理实例详解
08-26
JAVA线程池原理实例详解 JAVA线程池是java中的一种高效的线程管理机制，它可以控制线程的创建、销毁和复用，从而提高系统的性能和可靠性。下面我们将详细介绍JAVA线程池的原理、创建、使用方法及相关注意事项。 一...
Java线程池FutureTask实现原理详解
08-28
Java线程池FutureTask实现原理详解是Java多线程编程中的一种重要机制，用于追踪和控制线程池中的任务执行。下面将详细介绍FutureTask的实现原理。 类视图 为了更好地理解FutureTask的实现原理，我们需要了解一些...
Kotlin协程分析（一）——协程的创建过程和执行过程.pdf
08-30
Kotlin协程分析（一）——协程的创建过程和执行过程，资料参考Kotlin v1.4.0 源码及stdlib
如何给线程池命名
daysinsun的专栏
07-19 2218
        在系统运行后，在线程快照里总是看到线程池的名字为pool-xx，这样导致很不好定位，怎么给线程池一个有意义的名字呢。参照ThreadPoolExecutor类的ThreadFactory，自己实现ThreadFactory接口，重写newThread方法即可。参考代码如下：     public class NamedThreadFactory implements Thr...
NDK开发（六）：androidStudio3.2.1加载ffmpeg
黄孝果的博客
09-27 480
创建android项目并支持C++ 将编译好的so拷贝到项目libs中 将头文件拷贝到cpp文件下 配置gradle android { ..... sourceSets { main { jniLibs.srcDirs = ['libs'] } } } defaultConfig { ...... nd...
pdf 深入理解kotlin协程_深入理解协程、LiveData 和 Flow
weixin_39939918的博客
12-02 688
阅读前请点击右上角“关注”，每天免费获取Android知识解析及面试解答。Android架构解析，只做职场干货，完全免费分享！从 API 1 开始，处理 Activity 的生命周期 (lifecycle) 就是个老大难的问题，基本上开发者们都看过这两张生命周期流程图:随着 Fragment 的加入，这个问题也变得更加复杂:而开发者们面对这个挑战，给出了非常稳健的解决方案: 分层架构。分层架构如上...
python异步爬虫原理_python爬虫:基于gevent异步爬虫的原理及实现
weixin_39640090的博客
11-30 273
这张真的很好看啊当你写爬虫写了一段时间，你开始觉得这个爬虫怎么那么慢，明明代码优美没有bug。所以你不会去想方设法降低你爬虫的时间复杂度或者空间复杂度，你清楚的知道机器的大部分时间花在了网络IO上。想提速怎么办？加钱买带宽买机器啊！好的本文结束，大家散了散了。哎哎哎，你们刀放下我好好说话。看标题猜到，本文爬虫提速方式是用异步机制。先看看这个与你的同步爬虫有什么差别?你需要先了解两（四）个概...
正则表达式验证工具类
nano-dhh
03-19 518
转自：http://www.oschina.net/code/snippet_2321767_46245 package com.eabax.util; import java.util.regex.Matcher; import java.util.regex.Pattern; /** * 验证工具类 * @author admin * */ public class
java自定义线程池名称(给线程池自定义名称)
zy103118的博客
09-20 7421
java自定义线程池名称(给线程池自定义名称)
pdf 深入理解kotlin协程_我写了一本书，《深入理解 Kotlin 协程》 | Bennyhuo
weixin_42298927的博客
01-17 565
呜呜呜，昨天没有怎么看，来晚了。第三章是实战篇，直接看还是有点困难，我翻了翻源码。本章讲了如何实现简单的协程，我用自己方式整理一下。首先，我们可以从样本代码出发，协程是一个Continuation对像，通过resume方式恢复运行。SafeContinuation的resumeWith会对协程的状态检查并更新，成功后会传递结果给被代理的协程，即我们写的处理函数。第一次启动协程的时候，resume函...
JAVA线程池详解：原理与常见类型及优势
Java线程池是Java并发编程中一种核心的设计模式，它通过管理一组预先创建的线程来执行可重复的任务，从而提高系统性能并避免资源浪费。在设计服务器应用程序时，尤其是在处理大量短小任务的场景中，线程池显得尤为...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值