线程池总结

最新推荐文章于 2022-09-01 21:14:45 发布
最新推荐文章于 2022-09-01 21:14:45 发布
阅读量1.2k 收藏
点赞数
分类专栏： 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方法
Spring Boot中如何配置线程池拒绝策略，妥善处理好溢出的任务
m0_63175850的博客
11-07 1350
} 第二步：用@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
并发与多线程(四) --- 线程池
weixin_47081743的博客
11-02 630
文章目录一、线程池的好处1.1 线程池的作用：1.2 线程是如何创建的二、使用步骤1.引入库2.读入数据总结 一、线程池的好处 线程使应用能够更加充分合理地协调利用CPU、内存、网络、I/O等系统资源。线程的创建需要开辟虚拟机栈、本机方法栈、程序计数器等线程私有的内存空间。在线程销毁时需要回收这些资源。 频繁地创建和销毁线程会浪费大量的系统资源，增加并发编程风险。另外，在服务器负载过大的时候，如何让新的线程等待或者友好地拒绝服务？这些都是线程自身无法解决的。 所以需要通过线程池协调多个线程，并实现类似主次
线程池
qq_22899047的博客
05-20 528
Executor(定义) public interface Executor { /** * Executes the given command at some time in the future. The command * may execute in a new thread, in a pooled thread, or in the calling * thread, at the discretion of the {@code Executor}
并发工具四之线程池
qq_35576976的博客
07-01 435
线程池
让线程池依次无限循环执行下去
fwch1982的专栏
07-17 1825
让线程池依次无限循环执行下去，不用timertask方式，因为用timertask方式，间隔的时间不好确定，每次执行的线程池执行的时间不定，比如将间隔时间设置为20分钟，结果一个线程池11分钟就结束了，那么就会有9分钟空闲了，效率不高。       有两种方法实现：1.public abstract class BasicExecutor  {     public Logger log =
【Java进阶】线程池之无限队列 - 使用工厂类Executors.newFixedThreadPool(n) ，创建无限队列线程池
卡萨的博客
11-20 2416
线程池底层实现 线程池的底层实现是：ThreadPoolExecutor 使用工厂类Executors快速创建预定义线程池 IDEA插件Alibaba Java Coding Guidelines，代码提示如下（马云不推荐使用啊） 线程池不允许使用 Executors 去创建，而是通过 ThreadPoolExecutor 的方式，这样的处理方式让写的同学更加明确线程池的运行规则，规避资源耗尽的风险。 说明：Executors 返回的线程池对象的弊端如下： 1） FixedThreadPool 和
MYSQL线程池总结
12-14
线程池是Mysql5.6的一个核心功能，对于服务器应用而言，无论是web应用服务还是DB服务，高并发请求始终是一个绕不开的话题。当有大量请求并发访问时，一定伴随着资源的不断创建和释放，导致资源利用率低，降低了服务...
Java线程池总结
m0_73493267的博客
09-01 783
1）corePoolSize（线程池的基本大小）：当提交一个任务到线程池时，如果当前poolSize
Executor框架及线程池总结
m0_38017860的博客
04-07 887
概述Executor作为一个灵活且强大的异步执行框架，其支持多种不同类型的任务执行策略，提供了一种标准的方法将任务的提交过程和执行过程进行了解耦开发，基于生产者和消费者模型，还提供了对生命周期的支持，以及统计信息收集，应用程序管理机制和性能检测等机制。成员分为四个部分：任务、任务执行、任务执行结果以及任务执行工具类任务：实现Callable接口或Runnable接口任务执行部分：ThreadPoolExecutor以及ScheduledThreadPoolExecutor任务执行结果：Future接口以及F
最全的八股文线程池总结
m0_67322837的博客
05-27 409
这一期给我大家带来线程池，详细的聊一聊线程池，线程池在大厂的面试中也是高频率被问到。 而且，如果说你的简历上有写着线程池的使用的案例场景以及调优的经验，基本上你的这份简历会受到大厂面试官的青睐。 多线程一直是一块难啃的骨头，但是又是非常重要的一块内容。说它难啃主要是因为多线程开发中，需要考虑的东西很多。 比如：何如在多线程并发写的情况下，保证你的数据一致性，不会别其他线程覆盖，很多人也会考虑到使用锁（分布式锁redisLock、单机版锁、乐观锁、cas）来保证数据的一致性。 但是，同时你也要考虑QP
多线程-常见四种类型线程池总结
weixin_43517271的博客
10-25 1649
线程 线程池的概念： 在Java 5之后，并发编程引入了一堆新的启动、调度和管理线程的API。Executor框架便是Java5中引入的，其内部使用了线程池机制，它在java.util.cocurrent 包下，通过该框架来控制线程的启动、执行和关闭，可以简化并发编程的操作. Eexecutor作为灵活且强大的异步执行框架，其支持多种不同类型的任务执行策略，提供了一种标准的方法将任务的提交过程和执行过程解耦开发，基于生产者-消费者模式，其提交任务的线程相当于生产者，执行任务的线程相当于消费者，并用Runna
并发专题之---线程池
qq_42292373的博客
11-08 436
文章目录一: 为什么要用线程池二: 线程池常用的3个方式 一: 为什么要用线程池 二: 线程池常用的3个方式
Java线程池了解一下
dearKundy的博客
01-28 2241
为什么需要使用线程池 1、减少线程创建与切换的开销 在没有使用线程池的时候，来了一个任务，就创建一个线程，我们知道系统创建和销毁工作线程的开销很大，而且频繁的创建线程也就意味着需要进行频繁的线程切换，这都是一笔很大的开销。 2、控制线程的数量 使用线程池我们可以有效地控制线程的数量，当系统中包含大量并发线程时，会导致系统性能剧烈下降。 线程池做了什么 重复利用有限的线程 线程池中会预先创...
Java并发线程池原理解析
qq_45065241的博客
06-23 614
线程 1. 概述 线程是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。 2. 生命周期： 当线程被创建并启动以后，它既不是一启动就进入了执行状态，也不是一直处于执行状态。在线程的生命周期中，它要经过新建（New）、就绪（Runnable）、运行（Running）、阻塞（Blocked）和死亡（Dead）五种状态。尤其是当线程启动以后，它不能一直“霸占”着CPU独自运
线程池相关问题
qq_37822914的博客
11-23 348
线程池怎么动态调整参数 被问到的时候我也被整蒙了。我知道线程池大概怎么使用，但是因为项目没使用到过，所以还真不知道怎么动态调整。唯一知道的是核心线程数与最大线程数的区别是核心线程数去工作队列取任务不会超时，所以线程一直存在，而多出来的线程数取任务会存在超时的情况，自然而然就结束了。当时因为不确定是否有此api可以运行时改变参数，所以不敢贸然回答。 ThreadPoolExecutor的几个参数就不去解释了。 我自己百度并且尝试了一下，发现衍生的4种线程池都没有相关的api设置参数，只有threadp
多线程：线程池的拒绝策略
zhaoliubao1的博客
11-15 740
当线程池中的资源全部被占用时，对于新添加的runnable有不同的处理策略，默认情况下有如下四种拒绝策略： RejectedExecutionHandler rejected = null; rejected = new ThreadPoolExecutor.AbortPolicy();//默认，队列满了丢任务抛出异常 rejected = new ThreadPoolEx...
线程池invokeAll方法详解
热门推荐
sinat_40409279的博客
08-22 1万+
线程池invokeAll方法详解问题起源与抽象问题排查与猜测猜测一：invokeAll 在异步执行后会不会同步等待线程执行完毕获取最终结果猜测二：队列里面可能存在第一次调用 invokeAll 执行了但没有删掉的任务，所以才会导致第二次放入队列失败两次猜测失败后的总结复查源码，真相大白问题解决方案参考 线上真实案例，多次调用线程池 ThreadPoolExecutor 的 invokeAll() ...
线程池原理及使用
zhangjian_eng的博客
07-16 209
线程池原理及使用一、背景二、原理三、4种创建方法官方强烈建议程序员使用更方便的 `Executors`工厂方法使用构造函数创建线程池七大参数：异常：4种拒绝策略：四、封装线程池工具类 一、背景 线程池的作用是管理线程对象，避免重复new Thread消耗资源，控制资源的访问 二、原理 [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-kTH7RpTE-1626412025146)(images/线程池.png)] 线程池由主线程创建，刚创建时，里面没有一个线程。任务队列是作为参数
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值