初学者的线程池干货

最新推荐文章于 2023-09-04 20:56:45 发布
最新推荐文章于 2023-09-04 20:56:45 发布
阅读量197 收藏
点赞数
文章标签： 线程池 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Lizhiyi_LBB/article/details/120440221
版权





前言

平时工作中接触多线程并不是很多，自己对多线程也是迷茫，所以在网上搜了些，加上自己的一些见解，希望这篇文章和下面的链接可以带你入门线程池。





一、线程池基础

很好的入门文章

AtomicInteger的用法

盘它AtomicInteger

CountDownLatch详解





二、Demo上手





1.实现功能

多线程实现集合中的每一个元素-1





2.代码

2.1新增list

        List<Integer> list=new ArrayList<>();
        for (int i=0;i<502;i++){
            list.add(i);
        }

2.1线程池配置

        int listSize=list.size();
        //一个线程处理多少条数据
        int part=10;

        //10个为一段  有余数的段数+1
        int segmentedNum=listSize%part!=0?listSize/part+1:listSize/part;

        //是否有余数标识
        boolean status=listSize%part==0;
        
        //配置countDownLatch   等待所有线程执行完
        CountDownLatch countDownLatch=new CountDownLatch(segmentedNum);
        int corePoolSize=4;
        int maximumPoolSize=8;
        long keepAliveTime=10;
        TimeUnit unit=TimeUnit.SECONDS;
        //自定义阻塞队列
        BlockingQueue<Runnable> workQueue=new ArrayBlockingQueue<>(10);
        //自定义线程工厂
        MyThreadFactory threadFactory=new MyThreadFactory();
        //自定义拒绝策略
        RejectedExecutionHandler handler=new MyRejectedExecutionHandler();
        ThreadPoolExecutor threadPoolExecutor=new ThreadPoolExecutor(corePoolSize,maximumPoolSize,
                keepAliveTime,unit,workQueue,threadFactory,handler);
        //启动所有核心线程
        threadPoolExecutor.prestartAllCoreThreads();

2.3自定义线程工厂

class MyThreadFactory implements ThreadFactory{

        private final AtomicInteger mThreadNum=new AtomicInteger(1);

        @Override
        public Thread newThread(Runnable r) {
            Thread t=new Thread(r,"my-thread-"+mThreadNum.getAndIncrement());
            System.out.println(t.getName()+" has been created");
            return t;

    }
}

2.4自定义拒绝策略

class MyRejectedExecutionHandler implements RejectedExecutionHandler{
    @Override
    public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
        System.out.println(Thread.currentThread().getName()+"被拒绝了");
        System.out.println(r.toString() + " rejected");
        System.out.println(executor.getCompletedTaskCount());
        if (!executor.isShutdown()) {

            System.out.println(Thread.currentThread().getName()+"将要执行自己的run方法");
            //当前线程调用自己的run方法而不是开启新的线程
            r.run();

        }
    }
}

2.5自定义线程实现类(业务逻辑 list元素-1)

class MyTask implements Callable<List<Integer>>{
    private List<Integer> inList;

    //这是个线程安全的list
    private List<Integer> outList;

    //计数器  线程执行一次便向下减1
    private  CountDownLatch latch;

    public CountDownLatch getLatch() {
        return latch;
    }

    public void setLatch(CountDownLatch latch) {
        this.latch = latch;
    }

    public List<Integer> getOutList() {
        return outList;
    }

    public void setOutList(List<Integer> outList) {
        this.outList = outList;
    }

    public List<Integer> getInList() {
        return inList;
    }

    public void setInList(List<Integer> inList) {
        this.inList = inList;
    }

    public MyTask(List<Integer> inList, List<Integer> outList) {
        this.inList = inList;
        this.outList = outList;
    }

    public MyTask(List<Integer> inList, List<Integer> outList, CountDownLatch latch) {
        this.inList = inList;
        this.outList = outList;
        this.latch = latch;
    }

    @Override
    public List<Integer> call() throws Exception {

        for (Integer value : inList) {
            //线程安全的list所以不会有插入数量与实际数量不同
            outList.add(value-1);
        }

        //多线程的线程名
        Thread thread=Thread.currentThread();
        System.out.println(thread.getName());
//        Thread.sleep(5000);
        latch.countDown();

        return outList;
    }

2.6实现类业务逻辑

        List<Integer> tmpList=null;
        //线程安全的保存list元素-1的集合
        List<Integer> outList= Collections.synchronizedList(new ArrayList<>());
        List<Future> futures=new ArrayList<>();
        //一个线程取其中的一段处理
        for (int i=0;i<segmentedNum;i++){
            if (status) {
                //没有余数
                tmpList = list.subList(i*part, (i + 1) * part);
            }else {
                //最后一次循环
                if (i==segmentedNum-1){
                tmpList = list.subList(i*part,listSize);
                }else{
                    tmpList = list.subList(i*part, (i + 1) * part);
                }
            }

            MyTask myTask=new MyTask(tmpList,outList,countDownLatch);
            futures.add( threadPoolExecutor.submit(myTask));
        }



        try {
            //等待所有线程执行完成再执行下一段代码⬇⬇⬇⬇⬇⬇
            countDownLatch.await();
        }catch (InterruptedException e){
            e.printStackTrace();
        }


        //继续执行代码⬇⬇⬇⬇⬇⬇
        try {
            Thread.sleep(5000);
        }catch (InterruptedException e){}
        System.out.println("*******************");
        System.out.println(outList.size());
        System.out.println("*******************");
        //数据是混乱的额需要排序下输出
        Set set=new TreeSet(outList);
        for (Object o : set) {
            System.out.println(o.toString());
        }

        //如果不关闭线程池的话程序将会一直不结束  不会出现Process finished with exit code 0
        threadPoolExecutor.shutdown();

2.7整体代码

import java.util.*;
import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * Created by lizhiyi on 2021/9/9.
 */
@Service
public class ThreadPoolDemo{

    public static void main(String[] args) {
        ThreadPoolDemo threadPoolDemo=new ThreadPoolDemo();
        threadPoolDemo.batchProcessingList1();
        System.out.println("主程序执行完毕");
    }



    public  List<Integer> batchProcessingList1() {

        List<Integer> list=new ArrayList<>();
        for (int i=0;i<502;i++){
            list.add(i);
        }

        int listSize=list.size();
        int part=10;
        //10个为一段  有余数的段数+1
        int segmentedNum=listSize%part!=0?listSize/part+1:listSize/part;

        //是否有余数标识
        boolean status=listSize%part==0;
        CountDownLatch countDownLatch=new CountDownLatch(segmentedNum);
        int corePoolSize=4;
        int maximumPoolSize=8;
        long keepAliveTime=10;
        TimeUnit unit=TimeUnit.SECONDS;
        BlockingQueue<Runnable> workQueue=new ArrayBlockingQueue<>(10);
        MyThreadFactory threadFactory=new MyThreadFactory();
        RejectedExecutionHandler handler=new MyRejectedExecutionHandler();
        ThreadPoolExecutor threadPoolExecutor=new ThreadPoolExecutor(corePoolSize,maximumPoolSize,
                keepAliveTime,unit,workQueue,threadFactory,handler);
        threadPoolExecutor.prestartAllCoreThreads();

        List<Integer> tmpList=null;
        //线程安全的保存list元素-1的集合
        List<Integer> outList= Collections.synchronizedList(new ArrayList<>());
        List<Future> futures=new ArrayList<>();
        //一个线程取其中的一段处理
        for (int i=0;i<segmentedNum;i++){
            if (status) {
                //没有余数
                tmpList = list.subList(i*part, (i + 1) * part);
            }else {
                //最后一次循环
                if (i==segmentedNum-1){
                tmpList = list.subList(i*part,listSize);
                }else{
                    tmpList = list.subList(i*part, (i + 1) * part);
                }
            }

            MyTask myTask=new MyTask(tmpList,outList,countDownLatch);
            futures.add( threadPoolExecutor.submit(myTask));
        }



        try {
            //等待所有线程执行完成再执行下一段代码⬇⬇⬇⬇⬇⬇
            countDownLatch.await();
        }catch (InterruptedException e){
            e.printStackTrace();
        }


        //继续执行代码⬇⬇⬇⬇⬇⬇
        try {
            Thread.sleep(5000);
        }catch (InterruptedException e){}
        System.out.println("*******************");
        System.out.println(outList.size());
        System.out.println("*******************");
        //数据是混乱的额需要排序下输出
        Set set=new TreeSet(outList);
        for (Object o : set) {
            System.out.println(o.toString());
        }

        //如果不关闭线程池的话程序将会一直不结束  不会出现Process finished with exit code 0
        threadPoolExecutor.shutdown();
        return outList;
    }
}

/**
 * 自定义的线程工厂 用于生产线程
 * */
class MyThreadFactory implements ThreadFactory{

        private final AtomicInteger mThreadNum=new AtomicInteger(1);

        @Override
        public Thread newThread(Runnable r) {
            Thread t=new Thread(r,"my-thread-"+mThreadNum.getAndIncrement());
            System.out.println(t.getName()+" has been created");
            return t;

    }
}

/**
 * 自定义的拒绝策略  用以阻止线程池满了时候的拒绝策略
 *
 * 触发拒绝策略的条件：corePoolSize(核心线程数)、workQueue(阻塞队列)、maximumPoolSize(最大线程数)
 *
 * 借用一句：当提交任务数大于 corePoolSize 的时候，会优先将任务放到 workQueue 阻塞队列中。当阻塞队列饱和后，
 * 会扩充线程池中线程数，直到达到 maximumPoolSize 最大线程数配置。此时，再多余的任务，则会触发线程池的拒绝策略了。
 * 总结起来，也就是一句话，当提交的任务数大于(workQueue.size() + maximumPoolSize )，就会触发线程池的拒绝策略。
 *
 *
 *
 * 误区需注意：最大可提交任务数不是corePoolSize+workQueue+maximumPoolSize   且maximumPoolSize包含了corePoolSize
 * */
class MyRejectedExecutionHandler implements RejectedExecutionHandler{
    @Override
    public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
        System.out.println(Thread.currentThread().getName()+"被拒绝了");
        System.out.println(r.toString() + " rejected");
        System.out.println(executor.getCompletedTaskCount());


        //拒绝了怎么办   按照国际惯例  其实想什么都不做要么就抛出异常
        /**
         * AbortPolicy - 丢弃任务，并抛出拒绝执行 RejectedExecutionException 异常信息。线程池默认的拒绝策略。
         * 必须处理好抛出的异常，否则会打断当前的执行流程，影响后续的任务执行。
         *
         * 本例子使用了CallerRunsPolicy策略
         * CallerRunsPolicy - 当触发拒绝策略，只要线程池没有关闭的话，则使用调用线程直接运行任务。
         * */
        if (!executor.isShutdown()) {

            System.out.println(Thread.currentThread().getName()+"将要执行自己的run方法");
            //当前线程调用自己的run方法而不是开启新的线程
            r.run();

        }
    }
}

/**
 * 自定义线程类   为list中每个元素减一
 * */
class MyTask implements Callable<List<Integer>>{
    private List<Integer> inList;

    //这是个线程安全的list
    private List<Integer> outList;

    //计数器  线程执行一次便向下减1
    private  CountDownLatch latch;

    public CountDownLatch getLatch() {
        return latch;
    }

    public void setLatch(CountDownLatch latch) {
        this.latch = latch;
    }

    public List<Integer> getOutList() {
        return outList;
    }

    public void setOutList(List<Integer> outList) {
        this.outList = outList;
    }

    public List<Integer> getInList() {
        return inList;
    }

    public void setInList(List<Integer> inList) {
        this.inList = inList;
    }

    public MyTask(List<Integer> inList, List<Integer> outList) {
        this.inList = inList;
        this.outList = outList;
    }

    public MyTask(List<Integer> inList, List<Integer> outList, CountDownLatch latch) {
        this.inList = inList;
        this.outList = outList;
        this.latch = latch;
    }

    @Override
    public List<Integer> call() throws Exception {

        for (Integer value : inList) {
            //线程安全的list所以不会有插入数量与实际数量不同
            outList.add(value-1);
        }

        //多线程的线程名
        Thread thread=Thread.currentThread();
        System.out.println(thread.getName());
//        Thread.sleep(5000);
        latch.countDown();

        return outList;
    }
}

2.8效果图





总结

线程池基础的链接文章仔细读，写的都很好仔细阅读！！！

Lizhiyi_001
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
java中的 Future详解（以及ExecutorService中的各种方法）
Meiko记录
06-21 7902
关于这一块一前一直是一个盲点，看了看源码总结一下把。这一块内容和线程池也是息息相关的线程池的顶级接口是Executor接口,里面只有一个未实现方法是void execute(Runnable command);下来是ExecutorService接口，继承自Executor接口，里面多 了很多方法，比较重要的几个方法是 &lt;T&gt; List&lt;Future&lt;T&gt;&gt;...
新手一看就懂的线程池
好好学java
09-27 116
点击上方好好学java，选择星标公众号重磅资讯、干货，第一时间送达 今日推荐：Nginx 为什么快到根本停不下来？个人原创100W+访问量博客：点击前往，查看更多 相信大家也...
Java并发编程深入学习之线程池 超详细笔记
weixin_53142722的博客
05-14 715
线程池的使用，线程池构造方法详解，通过ThreadPoolExecutor自定义线程池，线程池提交任务的方式，关闭线程池的方式，线程池延时执行任务，线程池定时执行任务，Fork/Join
iservice list方法_java-将List <Future>转换为Future <List>序列
weixin_39832965的博客
12-19 1062
免责声明：这不会完全回答最初的问题。 它将缺少“如果一个失败就全部失败”部分。 但是，我无法回答实际的，更笼统的问题，因为它是作为以下内容的副本而被关闭的：Java 8 CompletableFuture.allOf(...)，带有Collection或List。 所以我会在这里回答：如何转换List>为 CompletableFuture>使用Java 8的流API？摘要：使用以...
java面试总结
qq_23873703的博客
02-21 168
1，java集合的框架结构 https://www.cnblogs.com/paddix/p/5539326.html 至于Vector，它是ArrayList的线程安全版本 与之前提到的HashSet与TreeSet的区别是一致的，在后续进行源码分析的时候，我们可以看到HashSet和TreeSet本质上分别是通过HashMap和TreeMap来实现的，所以它们的区别自然也是相同的。Has...
java future用法_Java并发编程-Future系列之Future的介绍和基本用法
weixin_39632698的博客
12-02 438
多线程(Multithreading)是Java的一个特性，它可以允许一个程序的多个部分(也就是线程)并发地执行，以达到最大程度利用CPU的目的。关于多线程编程(Multithread Programming)，下面介绍一下Future的特性和基本用法。 About FutureFuture(java.util.concurrent Interface Future<V>)表示异步计算...
IDAPython 初学者指南
05-27
IDAPython 初学者指南 IDAPython 初学者指南 IDAPython 初学者指南
VB 源代码大全 适合初学者
10-10
VB（Visual Basic）是微软公司开发的一种编程语言，属于Visual Studio家族的一部分，以其直观易用的界面和强大的功能深受初学者喜爱。这个“VB源代码大全”集合显然为初学者提供了一个良好的学习平台，通过实际的...
selenium初学者指南
03-20
**Selenium初学者指南** Selenium是一款强大的自动化测试工具，尤其在Web应用程序的测试领域，它占据了重要地位。本指南专为初次接触Selenium的读者设计，旨在帮助你们快速掌握这个强大的工具，从而提高测试效率，...
Oracle 9i初学者指南
01-30
Oracle 9i初学者指南是一本专为对数据库管理感兴趣的初学者设计的教程，它涵盖了Oracle 9i数据库系统的基础知识、安装配置、管理和维护等多个重要方面。Oracle 9i是Oracle公司推出的一个重要版本，引入了许多创新...
android笔记初学者必看
12-24
android笔记初学者必看 包含代码和知识要点 为求职做好充分准备
Java并发编程-并发工具
最新发布
weixin_56446161的博客
09-04 107
主要介绍了Java并发编程的并发工具。
二、Java线程池
狂奔的蜗牛
08-11 152
2.1、线程是不是越多越好？ 答：不是，原因如下： 线程的创建+销毁时间 > 执行任务的时间，这时就不划算了； JVM规范，一个线程默认最大栈大小是1M，需要从系统内存分配，线程过多会消耗很多内存。 OS会频繁切换线程上下文，导致每个线程比较慢，影响性能 合理的线程数量： 计算密集型：CPU（核心）数量的1~2倍。 IO密集型：需要多一些线程，根据具体的IO阻塞时长决定。Tomc...
flutter开发核心 Future/stream/bloc
qq_37683424的博客
09-13 528
Future(异步操作) Future有三种状态未完成、完成带有值、完成带有异常，使用Future可以简化事件任务。Dart中，可以使用Future对象来表示异步操作的结果，Future返回类型是Future<T> 有三种方法处理Future的结果： then: 处理操作执行结果或者错误并返回一个新的Future catchError: 注册一个处理错误的回调 whenComplete:类似final，无论错误还是正确，Future执行结束后总是被调用 使用then来回调，...
实现异步编程，这个工具类你得掌握！
月伴飞鱼
04-18 376
我们知道多线程能并发的处理多个任务，有效地提高复杂应用程序的性能，在实际开发中扮演着十分重要的角色 但是使用多线程也带来了很多风险，并且由线程引起的问题往往在测试中难以发现，到了线上就会造成重大的故障和损失 下面我会结合几个实际案例，帮助大家在工作做规避这些问题 多线程问题 首先介绍下使用的多线程会有哪些问题 使用多线程的问题很大程度上源于多个线程对同一变量的操作权，以及不同线程之间执行顺序的不确定性 《Java并发编程实战》这本书中提到了三种多线程的问题：安全性问题、活跃性问题和性能问题 安全性问题 例如
从Java future 到 Guava ListenableFuture实现异步调用
热门推荐
皮斯特劳沃
04-24 2万+
本文是在学习中的总结，欢迎转载但请注明出处： 前言      随着移动互联网的蓬勃发展，手机App层出不穷，其业务也随之变得错综复杂。针对于开发人员来说，可能之前的一个业务只需要调取一次第三方接口以获取数据，而如今随着需求的增加，该业务需调取多个不同的第三方接口。通常，我们处理方法是让代码同步顺序的去调取这些接口。显然，调取接口数量的增加必然会造成响应时间的增加，势必会对系统性能造成一定影响。
Google Guava 并发编程 - ListenableFuture
旧路
07-03 2576
       并发编程在咱们实际开发过程中肯定经常用到。比如线程池呀、通过Future去获取任务的执行结果呀等等。Guava从实际出发，为了方便我们的使用对JDK里面原生的一些并发编程方式做了增强。        Guava 里面并发编程相关的类非常多，我们对嘴常用的三个类MoreExecutors、Futures、L...
Guava - 并行编程Futures
weixin_34161083的博客
11-21 234
Guava为Java并行编程Future提供了很多有用扩展，其主要接口为ListenableFuture，并借助于Futures静态扩展。 继承至Future的ListenableFuture，允许我们添加回调函数在线程运算完成时返回值或者方法执行完成立即返回。 对ListenableFuture添加回调函数： Futures.addCallback(ListenableFuture&l...
常用api，适合初学者
04-25
这些API函数在MSDN（Microsoft Developer Network）上都有详细的文档，文档中提供了这些函数的参数说明、用法示例等详细内容，可以帮助初学者快速掌握这些API的使用方法。同时，MSDN还提供了各种实例代码，可以帮助...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值