并发五 线程池

最新推荐文章于 2024-02-19 14:02:35 发布
最新推荐文章于 2024-02-19 14:02:35 发布
阅读量256 收藏
点赞数
分类专栏： 并发
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Wen_ching_zhou/article/details/80707523
版权

作用

CPU的线程是稀有资源，创建和销毁需要成本较高，故在需要反复用到同一个线程的时候是可以使用线程池的

这里写图片描述

自定义线程池

package wen.ching.learn.base.multithread;

import org.junit.Test;

import java.util.HashSet;
import java.util.concurrent.*;

/**
 * @author Wen_ching on 2018/6/15.
 */
public class Pool {
    @Test
    public void teste() {
        ExecutorService pool = Executors.newCachedThreadPool();
        Future<?> submit = pool.submit(() -> {
        });

        pool.execute(() -> {
        });
    }

    @Test
    public void futureTimeOutTest() {
        System.out.println("main start");

        FutureTask<String> futureTask = new FutureTask<>(() -> {
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            return "111";
        });
        ExecutorService pool = Executors.newCachedThreadPool();
        pool.submit(futureTask);
        try {
            System.out.println("thread get   " + futureTask.get(3, TimeUnit.SECONDS));
            //主线程会阻塞 直到获取到值
            System.out.println("main over");
        } catch (Exception e) {
            e.printStackTrace();
        }
        pool.shutdown();
    }


    /**
     * 模拟ThreadPoolExecutor基本功能
     */
    static class MyThreadPoolV2 {
        private final  int queueMax = 10;//有界缓存队列大小 一般使用的无界队列

        //新建ThreadPoolExcutor需要一般需要如下参数 THreadFactory忽略
        private volatile int corePoolSize = 3;//核心线程数
        private volatile int maximumPoolSize = 8;//最大线程数
        private volatile RejectedExecutionHandler rejectHandle = new ThreadPoolExecutor.AbortPolicy();//拒绝策略 默认抛异常
        private volatile BlockingQueue<Runnable> workQueue = new ArrayBlockingQueue<>(queueMax);//缓存队列
        private volatile long keepAliveTime;//线程存活设置
        private volatile TimeUnit unit;//线程存活设置

//        private ThreadPoolExecutor threadPool = new ThreadPoolExecutor(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, rejectHandle);

        private volatile boolean isShutDown =false;//打开、关闭线程池

        public MyThreadPoolV2() {
        }

        public MyThreadPoolV2(int corePoolSize, int maximumPoolSize, RejectedExecutionHandler rejectHandle, BlockingQueue<Runnable> workQueue, TimeUnit unit, long keepAliveTime) {
            this.corePoolSize = corePoolSize;
            this.maximumPoolSize = maximumPoolSize;
            this.rejectHandle = rejectHandle;
            this.workQueue = workQueue;
            this.unit = unit;
            this.keepAliveTime = keepAliveTime;
        }

        //工作线程池 final修饰仅可被赋值一次 即地址不会变 但地址指向的内容可变
        private final HashSet<Thread> workerPool = new HashSet<>();
        public void execute(Runnable task){
            if(task==null) throw new NullPointerException();
            int workNum= workerPool.size();

            //已有工作线程小于核心线程数 则直接创造新线程执行
            if(workerPool.size() < corePoolSize){
                Worker worker=new Worker(task);
                Thread thread = new Thread(worker);
                System.out.println("开启核心线程执行新任务"+thread.getName()+"任务:" +task);
                workerPool.add(thread);//新创建的线程放入线程池中
                thread.start();
            } else if(workQueue.size()<10){//任务池还没满，就把任务放进任务池里
                System.out.println("核心线程已全部开启 新任务放入缓存队列"+task);
                workQueue.add(task);
            }
            else if(workNum<maximumPoolSize && workQueue.size()>=10){//任务队列满，开启多余线程来完成任务
                Worker worker=new Worker(task);
                Thread thread=new Thread(worker);
                System.out.println("缓存满了之后还有新任务则开启新线程至最大线程数并执行"+thread.getName()+"任务:" +task);

                workerPool.add(thread);
                thread.start();
            }
            else{
                System.out.println("拒绝执行，策略为放弃该任务什么也不做 或者抛异常等，任务" + task);
                return;
            }
        }

        public void shutdown(){
            this.isShutDown = true;
            for (Thread worker:
                    workerPool) {
                System.out.println("终止工作线程名：" + worker.getName());
                worker.interrupt();
            }

            System.out.println("终止线程池线程.");
            Thread.currentThread().interrupt();
        }


        private class Worker implements Runnable{//任务包装类
            private Runnable task_origal;
            public Worker() {
            }
            public Worker(Runnable task) {
                this.task_origal=task;
            }
            @Override
            public void run() {
                if(task_origal!=null)
                    task_origal.run();
                while(!isShutDown){
                    try {
                        //每个线程启动后会不断的去任务列表中去任务 线程自旋则不会被销毁
                        Runnable task=workQueue.take();//阻塞提取任务,阻塞状态下的中断并不会真的中断
                        task.run();
                    } catch (InterruptedException e) {//这个异常是BlockingQueue的
//                        e.printStackTrace();
                        System.out.println("真的终止了");
                        Thread.currentThread().interrupt();
                    }
                }
            }

        }
    }

    @Test
    public void MyThreadPoolV2Test() throws InterruptedException {
        MyThreadPoolV2 pool = new MyThreadPoolV2();

        for(int i= 0; i<20;i++){
            int finalI = i;
            pool.execute(new Runnable() {
                @Override
                public void run() {
                    try {
                        TimeUnit.SECONDS.sleep(1);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                    System.out.println(Thread.currentThread().getName() + "：" + finalI);
                }

                @Override
                public String toString() {
                    return "runable task:" + finalI;
                }
            });
        }

        TimeUnit.SECONDS.sleep(5);
        pool.shutdown();

    }

}

开启核心线程执行新任务Thread-0任务:runable task:0
开启核心线程执行新任务Thread-1任务:runable task:1
开启核心线程执行新任务Thread-2任务:runable task:2
核心线程已全部开启 新任务放入缓存队列runable task:3
核心线程已全部开启 新任务放入缓存队列runable task:4
核心线程已全部开启 新任务放入缓存队列runable task:5
核心线程已全部开启 新任务放入缓存队列runable task:6
核心线程已全部开启 新任务放入缓存队列runable task:7
核心线程已全部开启 新任务放入缓存队列runable task:8
核心线程已全部开启 新任务放入缓存队列runable task:9
核心线程已全部开启 新任务放入缓存队列runable task:10
核心线程已全部开启 新任务放入缓存队列runable task:11
核心线程已全部开启 新任务放入缓存队列runable task:12
缓存满了之后还有新任务则开启新线程至最大线程数并执行Thread-3任务:runable task:13
缓存满了之后还有新任务则开启新线程至最大线程数并执行Thread-4任务:runable task:14
缓存满了之后还有新任务则开启新线程至最大线程数并执行Thread-5任务:runable task:15
缓存满了之后还有新任务则开启新线程至最大线程数并执行Thread-6任务:runable task:16
缓存满了之后还有新任务则开启新线程至最大线程数并执行Thread-7任务:runable task:17
拒绝执行，策略为放弃该任务什么也不做 或者抛异常等，任务runable task:18
拒绝执行，策略为放弃该任务什么也不做 或者抛异常等，任务runable task:19
Thread-2：2
Thread-0：0
Thread-4：14
Thread-6：16
Thread-1：1
Thread-3：13
Thread-7：17
Thread-5：15
Thread-7：9
Thread-5：10
Thread-0：4
Thread-2：3
Thread-1：7
Thread-4：5
Thread-3：8
Thread-6：6
Thread-5：12
Thread-7：11
终止工作线程名：Thread-6
终止工作线程名：Thread-4
终止工作线程名：Thread-1
终止工作线程名：Thread-7
终止工作线程名：Thread-2
终止工作线程名：Thread-3
真的终止了
真的终止了
真的终止了
真的终止了
真的终止了
真的终止了
终止工作线程名：Thread-0
终止工作线程名：Thread-5
真的终止了
真的终止了
终止线程池线程.

原理总结

新任务放入线程封装类WorkerList 每个线程启动后会死循环的去workerlist中取任务 线程自旋则不会被销毁 则这个线程就可以一直使用 直到shutdown

其他在注解或打印信息中都写的很清楚，
至于空闲存活设置

//线程空闲存活时间 根据workQueue的poll方法来实现 如果队列为空 则等待时间后再去获
 Runnable task=workQueue.poll(keepAliveTime,unit);//阻塞提取任务,阻塞状态下的中断并不会真的中断
   if(task != null){
      task.run();
    }else{
         System.out.println(Thread.currentThread().getName()+"等待空闲线程超时 关闭该线程");
          Thread.currentThread().interrupt();
          }

ThreadPoolExecutor & Executors

ThreadPoolExecutor用于创建线程池

而Executors是线程池的工具类，提供了多种常见应用场景的线程池实例，创建线程池一般使用工具类则可
比如缓存线程池

//缓存线程池  有任务则直接新建线程
public static ExecutorService newCachedThreadPool() {
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                      60L, TimeUnit.SECONDS,
                                      new SynchronousQueue<Runnable>());
}
//单线程池
public static ExecutorService newSingleThreadExecutor() {
        return new FinalizableDelegatedExecutorService
            (new ThreadPoolExecutor(1, 1,
                                    0L, TimeUnit.MILLISECONDS,
                                    new LinkedBlockingQueue<Runnable>()));
    }
    //固定线程数量
public static ExecutorService newFixedThreadPool(int nThreads) {
        return new ThreadPoolExecutor(nThreads, nThreads,
                                      0L, TimeUnit.MILLISECONDS,
                                      new LinkedBlockingQueue<Runnable>());
    }

再看下ThreedPoolExector封装的worker类
继承了AQS和runnable 功能上核心是run方法 而run方法核心调用的是如下getTask

private Runnable getTask() {
        boolean timedOut = false; // Did the last poll() time out?

        for (;;) {
            int c = ctl.get();
            int rs = runStateOf(c);

            // Check if queue empty only if necessary.
            if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {
                decrementWorkerCount();
                return null;
            }

            int wc = workerCountOf(c);

            // Are workers subject to culling?
            boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;

            if ((wc > maximumPoolSize || (timed && timedOut))
                && (wc > 1 || workQueue.isEmpty())) {
                if (compareAndDecrementWorkerCount(c))
                    return null;
                continue;
            }

            try {
                Runnable r = timed ?
                    workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
                    workQueue.take();
                if (r != null)
                    return r;
                timedOut = true;
            } catch (InterruptedException retry) {
                timedOut = false;
            }
        }
    }
文青_周
关注
专栏目录
高并发之线程池
明天
07-27 1074
1.如何实现高并发？ 硬件资源 磁盘，网卡，内存，cpu 软件 cpu->线程 i/o->
[Java高并发]线程池
weixin_44417042的博客
05-27 1404
线程池 GO！Java线程池线程池的优势线程池七大参数拒绝策略线程池的排队策略常见的线程池类型：常见的阻塞队列：CountDownLatch（线程计数器）CyclicBarrier（回环栅栏-等待至 barrier 状态再全部同时执行）CyclicBarrier的内部实现Semaphore(信号量-控制同时访问的线程个数)CyclicBarrier，CountdownLatch与Semaphore线程之间共享数据一二ThreadLocalAtmoici++线程不安全CAS机制优点缺点原子包 java.uti
并发 --- 5 线程的其他方法 线程队列 线程池 协程
aozhe9939的博客
01-14 124
一.线程的其他方法 　　1. theading.current_thread() 当前线程对象 　　2. .getName() 获取线程名 　　3. .ident() 获取线程id 　　4. threading.enumerate() 当前正在运行的线程对象的一个列表 　　5. threading.active_count() 当前...
ThreadPool shutdown 与shutdownNow
热门推荐
liulipuo的专栏
09-02 1万+
线程的暂停有两个方法
最新安卓集成环信SDK3.5.1步骤详解大白菜版本，记录下
我心飞扬不飘荡
10-26 2272
最近两天一直在查找集成环信SDK的博客与文章，找来找去，最新的集成过程详解也是环信官方SDK更新前的，大部分都是SDK3.4.1之前的，刚才测试环信SDK3.5.1测试成功后就来写篇文章记录下，在这里先感谢下这位大神的博客，附上连接，我是按照他写的博客一步一步测试成功的：https://blog.csdn.net/JerryWu145/article/details/52507451?locati...
JAVA高并发——线程池
码说芯语的博客
02-19 2231
线程池的实现、拒绝策略、自定义线程创建、扩展线程池、优化线程池线程数量、在线程池中寻找堆栈、Fork/join框架
Java高并发——线程池
guzhipeng的博客
05-19 1163
文章目录ExecutorExecutorServiceScheduledExecutorServiceAbstractExecutorServiceFutureFutureTaskThreadPoolExecutor参数描述常用方法Executors 在以前创建线程的方式： 创建并继承Thread类 实现Runnable接口 实现Callable接口 通过以上述方式我们创建线程很方便，但也存在很多弊端： 每次new Thread都会新建一个线程，而频繁创建会大大降低系统性能。因为创建、销毁线程均需要时
Java并发之线程池
十十办文武的博客
11-23 932
在高并发的 Java 程序设计中，编写多线程代码可以最大限度发挥现代多核处理器的计算能力，提升系统的吞吐和性能。线程是多线程代码的基础工具，但不能无限制增加线程的数量，线程的创建和销毁、所占内存都要消耗系统资源，如果处理不当，可能会导致 OOM，并且大量线程的回收也会给 GC 带来压力，延长停顿时间。在并发环境下，系统不能够确定在任意时刻中，有多少任务需要执行，有多少资源需要投入。为解决资源分配这个问题，线程池采用了“池化”(Pooling)思想。
Java并发—线程池
weixin_52450996的博客
12-04 308
Java线程池实现了Java高并发的、Java多线程的、可管理的统一调度器。
Java并发编程之线程池详解
qq_54469537的博客
08-20 1854
这篇博客主要介绍了线程池以及自定义线程池的实现，最后介绍了ThreadPoolExecutor类
MyIOCP_IOCP_并发_socket并发_高并发_线程池_
10-02
本文将深入探讨"IOCP (I/O完成端口)"这一技术，以及如何利用它来实现高效的并发socket通信，同时还会涉及线程池在并发编程中的应用。 IOCP（I/O完成端口）是Windows操作系统提供的一种高级I/O模型，它允许系统在...
java并发编程 线程池 异步编排
08-04
java并发编程相关总结
并发－线程池和阻塞队列
10-18
在Java编程中，"并发-线程池和阻塞队列"是两个核心概念，它们在多线程环境下处理任务调度和数据同步方面发挥着重要作用。线程池是一种管理线程资源的有效方式，而阻塞队列则常用于线程间通信和数据共享。 线程池...
numexpr-2.8.3-cp38-cp38-win_amd64.whl
10-14
numexpr-2.8.3-cp38-cp38-win_amd64.whl
ujson-5.3.0-cp311-cp311-win_amd64.whl
10-14
ujson-5.3.0-cp311-cp311-win_amd64.whl
基于MATLAB车牌识别程序技术实现面板GUI.zip
最新发布
10-14
vos3000
RJFireWall-maste赛资源
10-14
RJFireWall-maste赛资源
msgpack-1.0.4-cp39-cp39-win_amd64.whl
10-14
msgpack-1.0.4-cp39-cp39-win_amd64.whl
基于 YOLOv11 的混凝土缺陷检测系统（包含详细的完整的程序和数据）
10-14
内容概要：本文提供了从零开始搭建的基于 YOLOv11 模型的混凝土缺陷检测系统教程，覆盖了整个流程，如开发配置指导，训练集搭建、模型的使用方法到最终集成图形界面交付应用等内容，尤其注重图像预处理及增广手段的有效利用，帮助读者建立高效的系统以满足工程中的实时监测需求。此外还包括对未来发展方向的具体展望，比如引入新型检测器或进一步扩展故障类别。 适合人群：适用于具有一定Python基础、想探索目标检测领域尤其是从事土木工程质量监督的技术工作者。 使用场景及目标：适合对有形结构如混凝土建筑的质量检验需要的公司部门，以提高检测的精确度同时加快检测流程的速度。 其他说明：项目代码附在文中，方便大家快速上手测试并进一步深入研究。对于那些对模型效果不满意的，本文给出了提升系统效能的具体注意点，譬如持续优化迭代以及增加系统设置自由度。
juc并发编程线程池
06-18
Java并发工具包（Java Util Concurrency, JUC）提供了一个强大的线程池实现，即`java.util.concurrent.Executors`和`java.util.concurrent.ThreadPoolExecutor`。线程池是并发编程中常用的一种机制，它允许您预先...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值