JavaSE|线程池

最新推荐文章于 2023-08-07 20:43:39 发布
最新推荐文章于 2023-08-07 20:43:39 发布
阅读量256 收藏
点赞数
分类专栏： java语法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/HL_HLHL/article/details/88525352
版权

文章目录


当我们要使用线程的时候就去创建一个线程，这样实现起来非常简单，但是会有一个问题：如果并发的线程数量很多，并且每个线程都是执行一个时间很短的任务就结束了（就像是你开了家公司，给一个项目投资了10个亿但是最后的效益只有1块钱，你说亏不亏），这样频繁创建线程就会大大降低系统的效率，因为频繁创建线程和销毁线程需要时间。那么有没有一种办法使得线程可以复用，就是执行完一个任务，并不被销毁，而是可以继续执行其他的任务？在Java中可以通过线程池来达到这样的效果。今天我们就来详细讲解一下Java的线程池。

线程池的优点

  1. 降低资源消耗:通过重复利用已创建的线程降低线程创建和销毁带来的消耗。
  2. 提高响应速度:当任务到达时，任务可以不需要等待线程创建就能立即执行。
  3. 提高线程的可管理性:使用线程池可以统一进行线程分配、调度和监控。

在这里插入图片描述

ExecutorService:线程调度器
AbstractExecutorService:实现ExecutorService接口，完成了一些方法
ThreadPoolExecutor:统一管理调度，实现监控
ScheduledExecutorService:周期调度

线程池的实现原理

在这里插入图片描述

线程池的使用

线程池的创建

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

corePoolSize（线程池的基本大小）：当提交一个任务到线程池来执行任务的时候，线程池会创建一个线程来执行任务，即使其他空闲的基本线程能够执行新任务也会创建线程，等到需要执行的任务数大于线程池基本大小的时候就不再创建。如果调用了线程池的prestartAllCoreThreads()方法，线程池会提前创建并启动所有基本线程

runnableTaskQueue（任务队列）：用于保存等待执行的任务的阻塞队列。可以选择以下几个阻塞队列。
1.ArrayBlockingQueue:是一个基于数组的有界阻塞队列，此队列按照先进先出原则对元素进行排序。
2.LinkedBlockingQueue:一个基于链表结构的阻塞队列，此队列按先进先出排序元素，吞吐量高于ArrayBlockingQueue（处理能力高）。静态工厂方法Executors.newFixedThreadPool()使用了这个队列。
3.SynchronousQueue：一个不存储元素的阻塞队列。每个插入操作一直处于阻塞状态，吞 吐 量 通 常 要 高 于 Linked-BlockingQueue ， 静 态 工 厂 方 法Executors.newCachedThreadPool使用了这个队列。
4.PriorityBlockingQueue：一个具有优先级的无限阻塞队列。

maximumPoolSize（线程池最大数量）：线程池允许创建的最大线程数。如果队列满了，并且已创建的线程数小于最大线程数，则线程池会再创建新的线程执行任务。值得注意的是，如果使用了无界的任务队列这个参数就没什么效果。

keepAliveTime（线程活动保持时间）：线程池的工作线程空闲后，保持存活的时间。所以，如果任务很多，并且每个任务执行的时间比较短，可以调大时间，提高线程的利用率。

TimeUnit （ 线 程 活 动 保 持 时 间 的 单 位 ） ： 可 选 的 单 位 有 天 （ DAYS ） 、 小 时 （ HOURS ） 、 分 钟
（ MINUTES ） 、 毫 秒 （ MILLISECONDS ） 、 微 秒 （ MICROSECONDS ， 千 分 之 一 毫 秒 ） 和 纳 秒
（NANOSECONDS，千分之一微秒）。

RejectedExecutionHandler（饱和策略）：当队列和线程池都满了，说明线程池处于饱和状态，那么必须采取
一种策略处理提交的新任务。这个策略默认情况下是AbortPolicy，表示无法处理新任务时抛出异常。在JDK
1.5 中 Java 线 程 池 框 架 提 供 了 以 下 4 种 策 略 。
·AbortPolicy ： 直 接 抛 出 异 常 。 ( 默 认 采 用 此 策 略 )
·CallerRunsPolicy：只用调用者所在线程来运行任务。 ·DiscardOldestPolicy：丢弃队列里最近的一个任务，并执行当前任务。
·DiscardPolicy：不处理，丢弃掉。

向线程池提交任务

execute()和submit()方法提交任务。

范例:


package hhh.Test;

import java.util.concurrent.*;

public class test {
    public static void main(String[] args) {

        //用户自定义线程池
        ThreadPoolExecutor executor=new ThreadPoolExecutor(2,5,1,TimeUnit.MINUTES,new LinkedBlockingDeque<>());

        for(int i=0;i<10;i++) {
            //如果关闭了就结束
            if(executor.isTerminating()){
                break;
            }
            //Runnale,提交线程
            executor.submit(() -> System.out.println(Thread.currentThread().getName() + " submit"));

            executor.execute(() -> System.out.println(Thread.currentThread().getName() + " execute"));

            //Callable
            Future<String> future = executor.submit(() -> {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                return "hello";
            });

            try {
                System.out.println(future.get());
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (ExecutionException e) {
                e.printStackTrace();
            }

        }
        executor.shutdown();//安全关闭线程池
        //executor.shutdownNow();//立即关闭
        System.out.println(executor.isShutdown());
        System.out.println(executor.isTerminating());
    }
}

通过调用线程池的shutdown或shutdownNow方法来关闭线程池。它们的原理是遍历线程池中的工作线程，然后逐个调用线程的interrupt方法来中断线程，所以无法响应中断的任务可能永远无法终止。
区别:
shutdownNow首先将线程池的状态设置成STOP，然后尝试停止所有的正在执行或暂停任务的线程，并返回等待执行任务的列表。
shutdown只是将线程池的状态设置成SHUTDOWN状态，然后中断所有没有正在执行任务的线程。
只要调用了这两个关闭方法中的任意一个，isShutdown方法就会返回true。当所有的任务都已关闭后，才表示线程池关闭成功，这时调用isTerminaed方法会返回true。至于应该调用哪一种方法来关闭线程池，应该由提交到线程池的任务特性决定，通常调用shutdown方法来关闭线程池，如果任务不一定要执行完，则可以调用shutdownNow方法。

合理配置线程池

要想合理地配置线程池，就必须首先分析任务特性，可以从以下几个角度来分析。

任务的性质：CPU密集型任务、IO密集型任务和混合型任务。
任务的优先级：高、中和低。
任务的执行时间：长、中和短。
任务的依赖性：是否依赖其他系统资源，如数据库连接。

性质不同的任务可以用不同规模的线程池分开处理。CPU密集型任务应配置尽可能小的线程，如配置Ncpu+1个线程的线程池。由于IO密集型任务线程并不是一直在执行任务，则应配置尽可能多的线程，如2*Ncpu。混合型的任务，如果可以拆分，将其拆分成一个CPU密集型任务和一个IO密集型任务，只要这两个任务执行的时间相差不是太大，那么分解后执行的吞吐量将高于串行执行的吞吐量。如果这两个任务执行时间相差太大，则没必要进行分解。
可以通过Runtime.getRuntime().availableProcessors()方法获得当前设备的CPU个数。
优先级不同的任务可以使用优先级队列PriorityBlockingQueue来处理。它可以让优先级高的任务先执行。
注意：如果一直有优先级高的任务提交到队列里，那么优先级低的任务可能永远不能执行。
执行时间不同的任务可以交给不同规模的线程池来处理，或者可以使用优先级队列，让执行时间短的任务先执行。
依赖数据库连接池的任务，因为线程提交SQL后需要等待数据库返回结果，等待的时间越长，则CPU空闲时间就越
长，那么线程数应该设置得越大，这样才能更好地利用CPU。

Executor框架

Executor框架的两级调度模型

在这里插入图片描述

ThreadPoolExecutor详解

Executor框架最核心的类是ThreadPoolExecutor，它是线程池的实现类。通过Executor框架的工具类Executors，可以创建3种类型的ThreadPoolExecutor。

  1. 创建无大小限制的线程池：public static ExecutorService newCachedThreadPool()
  2. 创建固定大小的线程池：public static ExecutorService newFixedThreadPool(int nThreads)
  3. 单线程池：public static ExecutorService newSingleThreadExecutor()
FixedThreadPool详解
public static ExecutorService newFixedThreadPool(int nThreads) {
return new ThreadPoolExecutor(nThreads, nThreads,
           0L, TimeUnit.MILLISECONDS,
           new LinkedBlockingQueue<Runnable>());
}

FixedThreadPool 使 用 无 界 队 列 LinkedBlockingQueue 作 为 线 程 池 的 工 作 队 列 （ 队 列 的 容 量 为Integer.MAX_VALUE）。使用无界队列作为工作队列会对线程池带来如下影响。
1）当线程池中的线程数达到corePoolSize后，新任务将在无界队列中等待，因此线程池中 的线程数不会超过
corePoolSize。
2）由于1，使用无界队列时maximumPoolSize将是一个无效参数。
3）由于1和2，使用无界队列时keepAliveTime将是一个无效参数。
4）由于使用无界队列，运行中的FixedThreadPool（未执行方法shutdown()或 shutdownNow()）不会拒绝任务（不会调用RejectedExecutionHandler.rejectedExecution方法）。

范例：



package hhh.Test;

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

public class test {
    public static void main(String[] args) {

        //用户自定义线程工厂
        //开发中建议使用自定义的线程工厂
        ThreadFactory threadFactory=new ThreadFactory() {
            private final AtomicInteger id=new AtomicInteger(0);
            @Override
            public Thread newThread(Runnable r) {
                Thread thread=new Thread();
                thread.setName("Thread-Pool-Task-"+id.getAndIncrement());
//                thread.setPriority(1);
//                thread.setDaemon(true);
                return thread;
            }
        };

        ExecutorService service=Executors.newFixedThreadPool(5,threadFactory);
        for(int i=0;i<10;i++){
            service.submit(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName()+" "+LocalDate.now().toString());
                }
            });
        }
        if(!service.isTerminated()){
            service.shutdown();
        }
    }
}

FixedThreadPool适用于为了满足资源管理的需求，而需要限制当前线程数量的应用场合，适用于负载比较重的服务器。

SingleThreadPoolExecutor详解

SingleThreadExecutor是使用单个worker线程的Executor。

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

SingleThreadExecutor 的 corePoolSize 和 maximumPoolSize 被 设 置 为 1 。 其 他 参 数 与FixedThreadPool 相 同 。SingleThreadExecutor 使 用 无 界 队 列 LinkedBlockingQueue 作 为 线 程 池 的 工 作 队 列 ( 队 列 的 容 量 为Integer.MAX_VALUE).
范例：

import java.util.concurrent.*;
public class Test {
    public static void main(String[] args){
        ExecutorService executorService =
                Executors.newSingleThreadExecutor();
        for (int i = 0; i < 5; i++) {
            executorService.submit(new Runnable() {
                @Override
                public void run() {
                    for (int j = 0; j < 10; j++) {
                        System.out.println(Thread.currentThread().getName()+"、"+j);
                    }
                }
            });
        }
        executorService.shutdown();
    }
}

SingleThreadExecutor适用于需要保证顺序地执行各个任务；并且在任意时间点，不会有多个线程是活动的应用场景。

CachedThreadPool详解

CachedThreadPool是一个会根据需要创建新线程的线程池.


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

CachedThreadPool的corePoolSize被设置为0，即corePool为空；maximumPoolSize被设置为Integer.MAX_VALUE，即
maximumPool是无界的。这里把keepAliveTime设置为60L，意味着CachedThreadPool中的空闲线程等待新任务的最长时间为60秒，空闲线程超过60秒后将会被终止。

FixedThreadPool 和 SingleThreadExecutor 使 用 无 界 队 列 LinkedBlockingQueue 作 为 线 程 池 的 工 作 队 列 。
CachedThreadPool使用没有容量的SynchronousQueue作为线程池的工作队列，但CachedThreadPool的maximumPool是
无界的。这意味着，如果主线程提交任务的速度高于maximumPool中线程处理任务的速度时，CachedThreadPool会不断创建新线程。极端情况下，CachedThreadPool会因为创建过多线程而耗尽CPU和内存资源。

ScheduledThreadPoolExecutor详解

ScheduledThreadPoolExecutor继承自ThreadPoolExecutor。它主要用来在给定的延迟之后运行任务，或者定期执行任务。ScheduledThreadPoolExecutor的功能与Timer类似，但ScheduledThreadPoolExecutor功能更强大、更灵活。Timer对应的是单个后台线程，而ScheduledThreadPoolExecutor可以在构造函数中指定多个对应的后台线程。

范例：Timer的使用

import java.util.Timer;
import java.util.TimerTask;

public class test{
    public static void main(String[] args) {

        Timer timer=new Timer("Timer-Clear");
        timer.schedule(new TimerTask() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"当前时间 "+LocalDateTime.now());
            }
        },0,1000);
    }
}

ScheduledThreadPoolExecutor的执行流程图如下:
在这里插入图片描述

DelayQueue是一个无界队列，所以ThreadPoolExecutor的maximumPoolSize在ScheduledThreadPoolExecutor中没有什么意义（设置maximumPoolSize的大小没有什么效果）。ScheduledThreadPoolExecutor的执行主要分为两大部分。
1）当调用ScheduledThreadPoolExecutor的scheduleAtFixedRate()方法或者scheduleWithFixedDelay()方法时，会向ScheduledThreadPoolExecutor 的 DelayQueue 添 加 一 个 实 现 了 RunnableScheduledFutur 接 口 的
ScheduledFutureTask。
2）线程池中的线程从DelayQueue中获取ScheduledFutureTask，然后执行任务。
ScheduledThreadPoolExecutor为了实现周期性的执行任务，对ThreadPoolExecutor做了如下的修改。
1.使用DelayQueue作为任务队列。
2.获取任务的方式不同
3.执行周期任务后，增加了额外的处理

范例：定时和周期性线程池

import java.time.LocalDateTime;
import java.util.concurrent.*;

public class test{
    public static void main(String[] args) {

       ScheduledExecutorService spe= Executors.newScheduledThreadPool(5);
       //周期性任务
        //1.指定执行时间
        spe.schedule(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+" 当前时间 "+LocalDateTime.now());
            }
        },10,TimeUnit.SECONDS);

        //2.指定周期性执行
        spe.scheduleAtFixedRate(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+" 周期性执行 "+LocalDateTime.now());
            }
        },0,2,TimeUnit.SECONDS);

    }
}

在这里插入图片描述

HL_HLHL
关注
专栏目录
王道JavaSE阶段测试
05-31
6. **多线程**：线程的创建方式（继承Thread类和实现Runnable接口），线程同步（synchronized关键字，wait()，notify()，notifyAll()方法，Lock接口），线程池。 7. **网络编程**：Socket编程，ServerSocket，TCP与...
网站去色
热门推荐
chenlin_cl的专栏
08-16 14万+
这2010-8-8--2010-8-15几天是哀悼日 把自己的网站图片、还有其他的表格都变成黑白的，就是把整站变成灰色的。方法：这段代码可以变网页为黑白，将代码加到CSS最顶端就可以实现素装。 有一些站长的网站可能使用这个css 不能生效，是因为网站没有使用最新的网页标准协议 请将网页最头部的替换为以上代码。 有一些网站FLASH动画的颜色不能被CSS滤镜控制，可以在FLASH代码的和之间插入：
网站去色的通用方法（简单）
weixin_34090562的博客
09-02 7705
2019独角兽企业重金招聘Python工程师标准>>> ...
SE net：Squeeze-and-Excitation Networks论文解读
Sesen的木屋
10-09 1520
近期对有关注意力机制的两篇文章进行了解读。分别是可以嵌入到很多网络结构中去的SE block的提出论文SENet，以及在GAN生成领域引入注意力机制的SAGAN。这两篇文章都是很经典的文章，这里将其详细整理一下。 SE Net：Squeeze-and-Excitation Networks (CVPR2018) 这篇文章的主要贡献是对通道间的依赖关系、各通道特征的权重进行了学习和分配。...
蔚蓝色色天空
蔚蓝色的天空
05-07 1万+
天气正晴，心情还算比较好的一天，就这样慢慢的消亡掉了。 zheng
想将有色彩的视频进行去色处理就这样做
m0_71312938的博客
08-03 1万+
想将有色彩的视频进行去色处理就这样做
JavaSE笔记11111
最新发布
10-15
线程池是管理线程的工具，如ExecutorService，它可以有效地管理和控制线程的生命周期，提高系统资源的利用率。 反射是Java的动态类型特性，允许在运行时检查类、接口、字段和方法的信息，甚至可以动态调用方法和...
JavaSE.rar
11-25
- **线程池**：ExecutorService接口和ThreadPoolExecutor类，提高多线程应用的效率和可控性。 5. **网络编程**： - **Socket编程**：创建客户端和服务器进行TCP通信的类和方法。 - **URL和URLConnection**：用于...
JAVASE知识脑图
12-03
7. **多线程**：线程的创建与管理，包括Thread类和Runnable接口，线程同步机制（如synchronized关键字、wait()、notify()和notifyAll()），以及线程池的使用。 8. **反射机制**：通过反射可以动态地获取类的信息，...
JavaSE思维导图
07-07
- 线程池：ExecutorService、ThreadPoolExecutor和ScheduledThreadPoolExecutor的使用。 7. **网络编程** - Socket编程：TCP和UDP通信的基础，ServerSocket和Socket类的使用。 - URL与URLConnection：通过URL...
安全杂谈SSSH(SELinx+SSH)
chupaleng7218的博客
08-03 3138
Selinux 介绍 SELinux(Security-Enhanced Linux) 是美国国家安全局（NSA）对于强制访问控制的实现，是 Linux上最杰出的新安全子系统。NSA是在Linux社区的帮助下开发了一种访问控制体系，在这种访问控制体系的限制下，进程只能访问那些在他的任务中所需...
SAP abap如何得到数据库表字段信息及内表字段名
matinal 當冬夜漸暖 。公众号：matinal
08-07 1428
3、一般有关数据表的信息以及数据表的字段信息都有专门的数据库表存储的，用SE11去搜索dd*，会出来很多表，比如dd03vv等等。这个函数得到的字段信息会比上面一个函数得到字段信息多，字段信息更全，比如该字段是否是表的关键字段等信息。-decimals. "字段小数位。WRITE: / -name, "字段名称。-type_kind, "字段类型。三、动态表-获取动态字段-得到动态内表-显示。
如何下载并安装jdk13版本
SSS4362的博客
06-28 3233
本文是jdk13版本安装的保姆级教程,带你手把手的去官网下载jdk13版本,并在自己电脑脑上安装好jdk13版本.注意:本文不含jdk13环境变量的配置(下一次博客再讲述)
css 去色
江湖再见
04-14 3万+
有这么一个样式，可以在你实现无色和加色之间游刃有余。 网站设计师在设计网页时，有时将一块图片设计成灰色，鼠标移上去，图片就有颜色。一般的逻辑是做两张图片，然后在鼠标上做图片切换事件。当然这种方法可以完美是实现，  不过有个小瑕疵，就是你要切一倍的图片（有色 + 无色）。下面介绍样式实现，可以减少一倍量的工作哦。 // HTML CSS .grayscale img{filter: g
Java线程池的使用
辰小白
07-23 2638
前言 在Java中，我们可以利用多线程来最大化地压榨CPU多核计算的能力。但是，线程本身是把双刃剑，我们需要知道它的利弊，才能在实际系统中游刃有余地运用。 在进入主题之前，我们先了解一下线程池的基本概念。 线程池，本质上是一种对象池，用于管理线程资源。 在任务执行前，需要从线程池中拿出线程来执行。 在任务执行完成之后，需要把线程放回线程池。 通过线程的这种反复利用机制，可以有效地避免直接创建线程所带来的坏处。 我们先来看看线程池带来了哪些好处。 降低资源的消耗。线程本身是一种资源，创建和销毁线
2020最新Java线程池入门(超详细)
王傲旗的大数据之路
02-17 1万+
1 为什么要使用线程池? a.假如线程创建的时间是time1,线程执行的时间是time2,线程销毁的时间呢是time3,往往time1+time3>time2,所以频繁的创建线程,会消耗额外的时间 b.如果等到有任务来了,在去创建线程的话效率就会比较低,如不把线程放在某个地方,任务来了,直接把线程拿过来用比较好 c.线程池可以管理控制线程,线程是稀缺资源,如果不停地创建线程会消耗大量的系统资...
javaSE--线程池
peiwen_java的博客
04-28 203
一、newCachedThreadPool public class CachedThreadPoolDemo { public static void main(String[] args) { //创建线程池对象 ExecutorService executorService = Executors.newCachedThreadPool(); //提交任务 for (int i = 0; i < 20; i+...
JAVASE_线程_线程池详解-1
qq_58339397的博客
10-04 543
JAVASE_线程_线程池详解-1
JavaSE第7天：线程池与Lambda表达式实战
"线程池和Lambda表达式是Java编程中的重要概念。线程池是一种管理线程的技术，它允许多个任务并发执行，提高系统效率并优化资源利用。Lambda表达式则是Java 8引入的简洁函数式编程特性，简化了代码编写。本资源提供...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值