线程池总结

最新推荐文章于 2022-07-26 09:18:47 发布
最新推荐文章于 2022-07-26 09:18:47 发布
阅读量1.1k 收藏
点赞数
分类专栏： java基础 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mogbox/article/details/121319339
版权

run() 和start()方法区别

run()方法是普通方法的调用,通过idea断点调试,从始至终都是一个线程

在这里插入图片描述

start()调用会另开一个线程去执行

在这里插入图片描述

具体代码如下

package T1.threaddemo;

public class ThreadDemo extends Thread{

    private String name;
    public ThreadDemo(String name) {
        this.name=name;
    }

    @Override
    public void run() {
        System.out.println(name);
    }

    public static void main(String[] args) {
        //new ThreadDemo("monkey老师").run();
        new ThreadDemo("monkey老师").start();
    }
}

线程池为什么快 一个一个建线程为什么慢

测试:

一个一个创建线程,为什么慢?

因为每次创建都会底层调用cpu去分配资源,每次都调用cpu会导致慢

下面这个代码创建了多少个线程?

100001个

join方法去调用会怎么样?

得到的size大小要小于100000,join() 会让调用线程等待被调用线程结束后，才会继续执行。使用的场景为我们需要等待某个线程执行完成后才可继续执行的场景。

再调用了join方法会,调用的线程会一直等待被调用的线程执行完才会执行

join底层是调用Object的wait进行等待

package T1.threaddemo;

import java.util.ArrayList;
import java.util.List;
import java.util.Random;

public class ThreadTest {
    public static void main(String[] args) throws InterruptedException {
        long start=System.currentTimeMillis();//开始时间
        final Random random =new Random();
        final List<Integer> list=new ArrayList<>();
        for (int i = 0; i < 100000; i++) {
            Thread thread = new Thread(){
                @Override
                public void run() {
                    list.add(random.nextInt());
                }
            };
            thread.start();
            thread.join();
        }
        System.out.println("时间:"+(System.currentTimeMillis()-start));
        System.out.println("大小:"+list.size());

    }


}
时间:18962
大小:100000

线程池

package T1.threaddemo;

import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

public class ThreadPoolTest {
    public static void main(String[] args) throws InterruptedException {
        long start=System.currentTimeMillis();//开始时间
        final Random random =new Random();
        final List<Integer> list=new ArrayList<>();
        ExecutorService executorService = Executors.newSingleThreadExecutor();
        for (int i = 0; i < 100000; i++) {
            executorService.execute(new Runnable() {
                @Override
                public void run() {
                    list.add(random.nextInt());
                }
            });
        }
        executorService.shutdown();
        executorService.awaitTermination(1, TimeUnit.DAYS);
        System.out.println("时间:"+(System.currentTimeMillis()-start));
        System.out.println("大小:"+list.size());

    }
}
时间:59
大小:100000

线程池的7大参数

不同线程池执行MyTask任务快慢,这种快慢是针对MyTask任务,当任务量变大 这快慢都不一定了

package T1.threaddemo;

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

public class ThreadPoolDemo {

    public static void main(String[] args) {
        ExecutorService executorService1 = Executors.newCachedThreadPool();//快
        ExecutorService executorService2 = Executors.newFixedThreadPool(10);//慢
        ExecutorService executorService3 = Executors.newSingleThreadExecutor(); //最慢
        for (int i = 1; i <= 100; i++) {
            executorService1.execute(new MyTask(i));
        }
    }
}
class MyTask implements Runnable{

    int i=0;

    public MyTask(int i) {
        this.i = i;
    }

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"--"+i);
        try{
            Thread.sleep(1000L);
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

上面创建线程池的方法都是调用ThreadPoolExecutor()

在这里插入图片描述

七大参数:

第二个参数应该为:线程池最大线程数量,不应该是非核心线程数

在这里插入图片描述

newCachedThreadPool()

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

0:核心线程数为0

Integer.MAX_VALUE :最大线程数为0x7fffffff

60L :时间

TimeUnit.SECONDS :单位

new SynchronousQueue()); 队列:这里是个同步队列,同步队列只能放一个,有人取了才可以放下一个

package T1.threaddemo;

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

public class ThreadPoolDemo {

    public static void main(String[] args) {
        ExecutorService executorService1 = Executors.newCachedThreadPool();//快
        ExecutorService executorService2 = Executors.newFixedThreadPool(10);//慢
        ExecutorService executorService3 = Executors.newSingleThreadExecutor(); //最慢
        for (int i = 1; i <= 100; i++) {
            executorService1.execute(new MyTask(i));
        }
    }
}
class MyTask implements Runnable{

    int i=0;

    public MyTask(int i) {
        this.i = i;
    }

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"--"+i);
        try{
            Thread.sleep(1000L);
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

运用newCachedThreadPool();时候没线程里面有休眠时候运行结果为

...
pool-1-thread-86--86
pool-1-thread-87--87
pool-1-thread-88--88
pool-1-thread-89--89
pool-1-thread-90--90
....

当把休眠时间注释后会发现

​```java
pool-1-thread-16--86
pool-1-thread-27--87
pool-1-thread-15--56
pool-1-thread-28--88
pool-1-thread-19--89  不一定一一对应

因为线程复用

在这里插入图片描述

因为有些线程干完工作后会重新被用

newFixedThreadPool()

public static ExecutorService newFixedThreadPool(int nThreads) {
    return new ThreadPoolExecutor(nThreads, nThreads,
                                  0L, TimeUnit.MILLISECONDS,
                                  new LinkedBlockingQueue<Runnable>());
}

nThreads 核心线程数

nThreads 最大线程数 (相当于非核心员工为0,都是核心员工)

0L : 时间

TimeUnit.MILLISECONDS

当以该方法创建的线程池运行的结果:总共10个线程在运行

pool-2-thread-1--88
pool-2-thread-6--87
pool-2-thread-9--86
pool-2-thread-7--100
pool-2-thread-2--99
pool-2-thread-4--97
pool-2-thread-3--96

看下LinkedBlockingQueue())他有多长

 public LinkedBlockingQueue() {
        this(Integer.MAX_VALUE);
    }

在这里插入图片描述

这里如果把初始调用构造器时候传参为100,那么第一种和第二种方式谁快?

可以认为一样的,除非在业务逻辑上可能才有点差距

newSingleThreadExecutor()

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

1 核心线程数

1 最大线程数

0L : 时间

TimeUnit.MILLISECONDS

在这里插入图片描述

pool-3-thread-1--86
pool-3-thread-1--87
pool-3-thread-1--88
pool-3-thread-1--89
pool-3-thread-1--90
pool-3-thread-1--91

只有一个线程在工作

keepAliveTime

是指当线程池中线程数量大于corePollSize时，此时存在非核心线程，keepAliveTime指非核心线程空闲时间达到的阈值会被回收。 java核心线程池的回收由allowCoreThreadTimeOut参数控制，默认为false，若开启为true，则此时线程池中不论核心线程还是非核心线程，只要其空闲时间达到keepAliveTime都会被回收。 但如果这样就违背了线程池的初衷（减少线程创建和开销），所以默认该参数为false

阿里巴巴为什么不推荐使用自带的线程池工具类?

上面三种Excutors创建线程池的方法中不会出现OOM的是哪个?

是:newCachedThreadPool

创建线程的本质就是CPU,如果线程创建很多只会导致CPU利用百分百,不会导致内存溢出

队列是同步队列,每次最多只存一个

其他两中方法会出现OOM是为什么?

因为他们的队列是无限长的,线程多的时候用队列存起来,可能导致队列会非常长,出现OOM

推荐我们使用自定义线程

下面代码会出现什么问题呢?

执行第31个时候会先拒绝策略异常

package T1.threaddemo;

import java.util.concurrent.*;

public class ThreadPoolDemo {

    public static void main(String[] args) {
        ExecutorService executorService1 = Executors.newCachedThreadPool();//快
        ExecutorService executorService2 = Executors.newFixedThreadPool(10);//慢
        ExecutorService executorService3 = Executors.newSingleThreadExecutor(); //最慢
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
                10,
                20,
                0l,
                TimeUnit.SECONDS,
                new ArrayBlockingQueue<Runnable>(10));//自定义线程池
        for (int i = 1; i <= 100; i++) {
            threadPoolExecutor.execute(new MyTask(i));
        }
    }
}
class MyTask implements Runnable{

    int i=0;

    public MyTask(int i) {
        this.i = i;
    }

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"--"+i);
        try{
            Thread.sleep(1000L);
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

pool-4-thread-17--27
pool-4-thread-13--23
pool-4-thread-10--10
pool-4-thread-15--25
pool-4-thread-16--26
pool-4-thread-18--28
pool-4-thread-12--22
pool-4-thread-19--29
pool-4-thread-20--30
Exception in thread "main" java.util.concurrent.RejectedExecutionException: Task T1.threaddemo.MyTask@2b193f2d rejected from java.util.concurrent.ThreadPoolExecutor@355da254[Running, pool size = 20, active threads = 20, queued tasks = 10, completed tasks = 0]
	at java.util.concurrent.ThreadPoolExecutor$AbortPolicy.rejectedExecution(ThreadPoolExecutor.java:2063)
	at java.util.concurrent.ThreadPoolExecutor.reject(ThreadPoolExecutor.java:830)
	at java.util.concurrent.ThreadPoolExecutor.execute(ThreadPoolExecutor.java:1379)
	at T1.threaddemo.ThreadPoolDemo.main(ThreadPoolDemo.java:18)
pool-4-thread-12--11
pool-4-thread-17--12
pool-4-thread-7--17
pool-4-thread-10--20
pool-4-thread-9--19
pool-4-thread-1--18
pool-4-thread-8--16
pool-4-thread-16--13
pool-4-thread-13--14

为什么11-20会出现在21-30后面呢?

执行优先级

提交优先级

红色1 2 3为提交优先级

蓝色 1 2 3为执行优先级

在这里插入图片描述

提交优先级的源码

在这里插入图片描述
在这里插入图片描述

public void execute(Runnable command) {
    if (command == null) //空直接返回空指针异常
        throw new NullPointerException();
    /*
     * Proceed in 3 steps:
     *
     * 1. If fewer than corePoolSize threads are running, try to
     * start a new thread with the given command as its first
     * task.  The call to addWorker atomically checks runState and
     * workerCount, and so prevents false alarms that would add
     * threads when it shouldn't, by returning false.
     *
     * 2. If a task can be successfully queued, then we still need
     * to double-check whether we should have added a thread
     * (because existing ones died since last checking) or that
     * the pool shut down since entry into this method. So we
     * recheck state and if necessary roll back the enqueuing if
     * stopped, or start a new thread if there are none.
     *
     * 3. If we cannot queue task, then we try to add a new
     * thread.  If it fails, we know we are shut down or saturated
     * and so reject the task.
     */
    int c = ctl.get();
    if (workerCountOf(c) < corePoolSize) { //前面的10个先用核心的去处理
        if (addWorker(command, true))
            return;
        c = ctl.get();
    }
    if (isRunning(c) && workQueue.offer(command)) { //中间11-20用队列存
        int recheck = ctl.get();
        if (! isRunning(recheck) && remove(command))
            reject(command);
        else if (workerCountOf(recheck) == 0)
            addWorker(null, false);
    } //21-30用非核心来处理,当非核心处理不了就调拒绝策略
    else if (!addWorker(command, false))
        reject(command);
}

调用拒绝策略:有四种,默认调用第一种

final void reject(Runnable command) {
    handler.rejectedExecution(command, this);
}

在这里插入图片描述
在这里插入图片描述

执行优先级

在这里插入图片描述

public class ThreadPoolTest {
    public static void main(String[] args) throws InterruptedException {
        long start=System.currentTimeMillis();//开始时间
        final Random random =new Random();
        final List<Integer> list=new ArrayList<>();
        ExecutorService executorService = Executors.newSingleThreadExecutor();
        for (int i = 0; i < 100000; i++) {
            executorService.execute(new Runnable() {
                @Override
                public void run() {
                    list.add(random.nextInt());
                }
            });
        }
        executorService.shutdown();
        executorService.awaitTermination(1, TimeUnit.DAYS);
        System.out.println("时间:"+(System.currentTimeMillis()-start));
        System.out.println("大小:"+list.size());

    }
}
只创建了两个线程,里面是run方法的调用后进入runwork
public void run() {
            runWorker(this);
        }

runworker里面调的是task.run调用的普通方法不是start方法
final void runWorker(Worker w) {    
     wt.interrupt();
                try {
                    beforeExecute(wt, task);
                    Throwable thrown = null;
                    try {
                        task.run();
                    }

submit和execute方法的区别?

  1. submit有返回值 execute没有返回值
  2. submit里面调用了execute方法
zqhwboy
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
MYSQL线程池总结
12-14
线程池是Mysql5.6的一个核心功能，对于服务器应用而言，无论是web应用服务还是DB服务，高并发请求始终是一个绕不开的话题。当有大量请求并发访问时，一定伴随着资源的不断创建和释放，导致资源利用率低，降低了服务...
解决spring cloud报ThreadPoolExecutor [Running, pool size = 10, active threads = 10, queued tasks = 0 错误
星辰海的专栏
11-18 1万+
这个是我这边在生产环境碰到的问题，因为测试环境访问量不是很大，所以就没测出来。也没有压测，如果压测的话也可以轻易的压测出来这个问题，其实它具体的异常如下： java.util.concurrent.RejectedExecutionException: Task java.util.concurrent.FutureTask@7ed27b0 rejected from java.util.co...
Java 线程池抛 RejectedExecutionException 异常时 active threads 值分析
热门推荐
回归心灵的专栏
12-02 2万+
背景介绍 系统日志有 RejectedExecutionException 异常，抛异常的线程池是业务程序为了某类处理过程比较慢的请求创建的，线程资源隔离，避免阻塞这个系统。异常信息类似下面输出： java.util.concurrent.RejectedExecutionException: Task java.util.concurrent.FutureTask@56235b8e rejected from java.util.concurrent.ThreadPoolExecutor@49c2faa
Spring Boot中如何配置线程池拒绝策略，妥善处理好溢出的任务
m0_63175850的博客
11-07 1289
} 第二步：用@Async注解实现一个部分任务 @Slf4j @Component public class AsyncTasks { public static Random random = new Random(); @Async(“taskExecutor1”) public CompletableFuture doTaskOne(String taskNo) throws Exception { log.info(“开始任务：{}”, taskNo); long start = System.cu
Java线程池了解一下
dearKundy的博客
01-28 2089
为什么需要使用线程池 1、减少线程创建与切换的开销 在没有使用线程池的时候，来了一个任务，就创建一个线程，我们知道系统创建和销毁工作线程的开销很大，而且频繁的创建线程也就意味着需要进行频繁的线程切换，这都是一笔很大的开销。 2、控制线程的数量 使用线程池我们可以有效地控制线程的数量，当系统中包含大量并发线程时，会导致系统性能剧烈下降。 线程池做了什么 重复利用有限的线程 线程池中会预先创...
浅谈Spring @Async异步线程池用法总结
08-29
浅谈Spring @Async异步线程池用法总结 本文主要介绍了Spring @Async异步线程池的用法总结，包括异步线程池的接口类、@Async定义异步任务、Spring开启异步配置等内容。 1. 异步线程池的接口类 Spring提供了多种...
android线程池
01-19
总结，理解并熟练使用线程池是Android开发中的重要技能。合理选择和配置线程池，能有效提升应用性能，保证系统的稳定性和效率。在实际开发中，应结合任务特性和系统资源，选择合适的线程池类型，并对其进行适当的...
线程池实现源码
08-24
总结来说，POCO线程池提供了一种高效且易于使用的多线程解决方案，适用于各种跨平台的C++应用程序。通过合理配置和使用线程池，开发者可以优化系统资源的利用，提升应用程序的并发处理能力。对于VS2008用户来说，这...
线程池管理多线程上传
01-15
总结来说，线程池通过统一管理和复用线程，提高了多线程环境下的效率和稳定性。在文件上传场景中，线程池能有效利用系统资源，加速大文件的上传速度，同时通过合理的任务调度和等待机制，确保上传过程的可靠性和一致...
【多线程】@Async注解和线程池
weixin_45325628的博客
12-24 6981
快速了解@Async的使用
性能测试连载 (5)-jmeter 下的性能指标监听
ufuhz2008的博客
01-23 1046
性能指标监听 概述 性能测试过程中，想要得到比较靠谱的性能数据，就不得不对各种性能数据进行动态监听。jmeter中提供了很多性能数据的监听器，我们通过监听器可以来分析性能瓶颈 本文用吞吐量模式，演示200线程的负载测试结果来描述图表（压测百度） 常用监听器 Transactions per Second 监听动态TPS，用来分析吞吐量。其中横坐标是运行时间，纵坐标是TPS值。红色表示通过的TPS，...
线程池
遇卿
12-20 320
目录 Java线程池 Executors ThreadPoolExecutor 线程池原理 线程和线程池状态 总结 Spring线程池 ThreadPoolTaskExecutor类
Java并发线程池原理解析
qq_45065241的博客
06-23 551
线程 1. 概述 线程是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。 2. 生命周期： 当线程被创建并启动以后，它既不是一启动就进入了执行状态，也不是一直处于执行状态。在线程的生命周期中，它要经过新建（New）、就绪（Runnable）、运行（Running）、阻塞（Blocked）和死亡（Dead）五种状态。尤其是当线程启动以后，它不能一直“霸占”着CPU独自运
编程语言Spring Boot中如何配置线程池拒绝策略，妥善处理好溢出的任务
09-25 792
编程语言Spring Boot中如何配置线程池拒绝策略，妥善处理好溢出的任务 通过之前三篇关于Spring Boot异步任务实现的博文，我们分别学会了用@Async创建异步任务、为异步任务配置线程池、使用多个线程池隔离不同的异步任务。今天这篇，我们继续对上面的知识进行完善和优化！ 如果你已经看过上面几篇内容并已经掌握之后，一起来思考下面这个问题： 假设，线程池配置为核心线程数2、最大线程数2、缓冲队列长度2。此时，有5个异步任务同时开始，会发生什么？ 场景重现 我们先来把上面的假设用代码实现一
Feign调用异常[Running, pool size = 10, active threads = 10, queued tasks = 0, completed tasks = n]
xzh_blog
07-26 1929
java.util.concurrent.RejectedExecutionException: Task java.util.concurrent.FutureTask@1e882e6a rejected from java.util.concurrent.ThreadPoolExecutor@28cdff71[Running, pool size = 10, active threads = 10, queued tasks = 0, completed tasks = 25] at java.uti
线程池相关问题
qq_37822914的博客
11-23 327
线程池怎么动态调整参数 被问到的时候我也被整蒙了。我知道线程池大概怎么使用，但是因为项目没使用到过，所以还真不知道怎么动态调整。唯一知道的是核心线程数与最大线程数的区别是核心线程数去工作队列取任务不会超时，所以线程一直存在，而多出来的线程数取任务会存在超时的情况，自然而然就结束了。当时因为不确定是否有此api可以运行时改变参数，所以不敢贸然回答。 ThreadPoolExecutor的几个参数就不去解释了。 我自己百度并且尝试了一下，发现衍生的4种线程池都没有相关的api设置参数，只有threadp
Java线程池
weixin_43687944的博客
07-14 64
Java线程池 线程池是企业开发中常用的一种多线程处理形式，线程池中维护了一定数量的线程，线程池内的线程可以并发执行外部提交的多个任务。在开发过程中，合理地使用线程池能够带来许多好处。 一、线程池的优点： 1.降低资源消耗。线程池可以充分复用线程，让线程持续不断地处理任务，有效避免频繁创建和销毁线程造成的资源消耗。 2.提高响应速度。当任务到达时，任务可以不需要等待线程的创建就立即执行 3.提高线程的可管理性。线程是属于一种稀缺资源，如果无限制地创建线程，不仅会消耗系统资源，还会降低系统的稳定性 二、创建
Java 自定义线程池
最新发布
07-27
- *1* [java自定义线程池总结](https://blog.csdn.net/qq_21225505/article/details/125092169)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值