深入理解java线程池

最新推荐文章于 2023-12-04 08:04:35 发布
最新推荐文章于 2023-12-04 08:04:35 发布
阅读量1.3k 收藏 4
点赞数 5
分类专栏： 线程池进阶之路 文章标签： java 开发语言 后端 线程池
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liulong999/article/details/122293172
版权

一、为什么要用线程池？（线程池的概念）

1、线程池的引入就是为了管理线程的，操作系统需要频繁的切换线程上下文，影响性能。
2、线程池其实就是线程的池子，用来帮助我们重复利用线程，避免创建大量的线程增加开销，提高响应速度。

二、线程是不是越多越好？

1、线程并不是越多越好，因为线程的创建需要占用系统内存，根据jvm规范，一个线程默认最大栈大小为1M，线程越多，会消耗很多内存。
2、如果线程的创建时间+销毁时间>执行任务的时间，就没必要创建线程。

三、线程池的创建

1、线程池推荐手动创建，一般用ThreadPoolExecutor来创建，这个类有4个构造函数
在这里插入图片描述
我们先来理解一下线程池的这些参数

  • corePoolSize:线程池的核心线程数最大值
  • maximumPoolSize:线程池最大线程数大小
  • keepAliveTime:线程池中非核心线程空闲的存活时间大小
  • unit:线程空闲存活时间单位
  • workQueue:存放任务队列的阻塞队列
  • threadFactory:用于设置创建线程的工厂，可以给创建的线程设置有意义的名字，方便查看创建的线程
  • handler:线程池的拒绝策略，有4种类型
    a、AbortPolicy(直接抛异常，默认拒绝策略)
    b、DiscardPolicy(直接丢弃任务)
    c、DiscardOldestPolicy(丢弃队列里最老的任务，将当前这个任务继续提交给线程池)
    d、CallerRunsPolicy(直接交给调用方处理该任务)
这里演示一下

首先手动声明一个核心线程为1，最大线程为2，阻塞队列为2的线程，拒绝策略为直接丢弃任务，这时来了5个任务，会发现第一个任务来时，核心数为1 的线程可以处理，第二个任务来时就只能放到阻塞队列里了，第三个也放到阻塞队列里，第四个任务来时阻塞队列满了，这时候会开启一个线程达到最大线程来处理，第五个任务来时，线程池处理不了，直接丢弃任务，最终执行完会执行四个任务。

package com.threadpool;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

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


/**
 * @Author ll
 * @Description
 * @Date 1/3/22 10:00 PM
 **/
@SpringBootTest
@RunWith(SpringRunner.class)
public class ThreadPoolApplicationTest {

   @Test
    public void ThreadPoolExecutorTest(){

       ThreadFactory threadFactory = new ThreadFactory() {
           private AtomicInteger idx = new AtomicInteger(1);
           private static final String THREAD_NAME_PREFIX = "mythread-pool-";
           @Override
           public Thread newThread(Runnable r) {
               return new Thread(r, THREAD_NAME_PREFIX + idx.getAndIncrement());
           }
       };

       ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(1, 2,
               100, TimeUnit.SECONDS, new LinkedBlockingQueue<>(2),
               threadFactory, new ThreadPoolExecutor.DiscardPolicy());

       Runnable runnable = () -> {
           System.out.println("当前任务被执行,线程:" + Thread.currentThread().getName() + "正在执行");
           try {
               // 等待 1s
               TimeUnit.SECONDS.sleep(1);
           } catch (InterruptedException e) {
               e.printStackTrace();
           }
       };

       threadPoolExecutor.submit(runnable);
       threadPoolExecutor.submit(runnable);
       threadPoolExecutor.submit(runnable);
       threadPoolExecutor.submit(runnable);
       threadPoolExecutor.submit(runnable);

       try {
           // 等待 10s
           TimeUnit.SECONDS.sleep(10);
       } catch (InterruptedException e) {
           e.printStackTrace();
       }

   }


}

在这里插入图片描述
其它情况类似。大家可以尝试写一下。

2、 也可以用线程池工具类来创建，但是不推荐，至于为什么不推荐，下面会说，我们先来看一下这个Executors提供了哪些方法来创建线程池。
在这里插入图片描述
可以看出=提供了如下4种方式来创建不同的线程池

  • newFiexedThreadPool(int Threads)：创建固定数目线程的线程池。
package com.threadpool;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

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

/**
 * @Author ll
 * @Description
 * @Date 1/3/22 11:36 PM
 **/
@SpringBootTest
@RunWith(SpringRunner.class)
public class FixedThreadPoolTest {

    @Test
    public void fixedThreadPoolTest(){
        ExecutorService executorService = Executors.newFixedThreadPool(2);
        Runnable runnable = () -> {
            System.out.println("线程:" + Thread.currentThread().getName() + "正在执行");
        };
        for(int i = 0; i < 5; i++){
            executorService.submit(runnable);
        }
		executorService.shutdown();
    }

}

在这里插入图片描述

  • newSingleThreadExecutor()：创建一个单线程化的Executor。
package com.threadpool;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

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

/**
 * @Author ll
 * @Description
 * @Date 1/3/22 11:44 PM
 **/
@SpringBootTest
@RunWith(SpringRunner.class)
public class SingleThreadExecutorTest {

    @Test
    public void singleThreadExecutorTest(){
        ExecutorService executorService = Executors.newSingleThreadExecutor();
        for(int i = 0; i < 5; i++){
            executorService.submit(() -> {
                System.out.println("线程:" + Thread.currentThread().getName() + "正在执行");
            });
        }
        executorService.shutdown();
    }
}

在这里插入图片描述

  • newCachedThreadPool(): 创建一个可缓存的线程池，调用execute将会重用以前构造的线程（如果线程可用），如果没有可用的线程，则会创建一个新的线程并添加到池中，最后使用完会从缓存中移除那些已经超过60秒未被使用的线程。
package com.threadpool;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

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

/**
 * @Author ll
 * @Description
 * @Date 1/3/22 11:57 PM
 **/
@SpringBootTest
@RunWith(SpringRunner.class)
public class CachedThreadPoolTest {

    @Test
    public void cachedThreadPoolTest(){
        ExecutorService executorService = Executors.newCachedThreadPool();
        for (int i = 0; i < 5; i++){
            executorService.submit(()->{
                System.out.println("线程:" + Thread.currentThread().getName() + "正在执行");
            });
        }
        executorService.shutdown();
    }
}

在这里插入图片描述

  • newScheduledThreadPool(int corePoolSize): 创建一个支持定时及周期性的任务执行的线程池，多数情况下可以替代Timer类。
import org.junit.runner.RunWith;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

import java.util.concurrent.ScheduledThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/**
 * @Author ll
 * @Description
 * @Date 1/4/22 12:00 AM
 **/
@SpringBootTest
@RunWith(SpringRunner.class)
public class ScheduledThreadPoolTest {

    @Test
    public void scheduledThreadPoolTest() {
        ScheduledThreadPoolExecutor scheduledThreadPoolExecutor = new ScheduledThreadPoolExecutor(2);
        for(int i = 0; i < 5; i++){
            scheduledThreadPoolExecutor.schedule(() -> {
                System.out.println("线程:" + Thread.currentThread().getName() + "正在执行" + DateUtil.now());
            }, 1, TimeUnit.SECONDS);
        }
        try {
            TimeUnit.SECONDS.sleep(5);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("任务执行完毕");
        scheduledThreadPoolExecutor.shutdown();
    }
}

在这里插入图片描述

3、下面说明一下为什么不推荐使用Executors直接创建线程

  • newFiexedThreadPool(int Threads)的源码可以看出，阻塞队列没有设置大小，默认是Integer.MAX_VALUE，可以认为是无界的，最终可能会导致OOM。
    在这里插入图片描述
  • newSingleThreadExecutor()源码可以看出线程池中只有一个线程，而阻塞队列也没有指定大小，默认也是Integer.MAX_VALUE，可以认为是无界的，最终可能会导致OOM。
    在这里插入图片描述
  • newCachedThreadPool()源码可以看出，核心线程此处是0个，最大线程为Integer.MAX_VALUE，可以认为是无界大，SynchronousQueue()一个不存储元素的阻塞队列，即直接提交给线程不保持它们，可能会创建无限个线程，最终可能会导致OOM。
    在这里插入图片描述
  • newScheduledThreadPool(int corePoolSize)源码可以看出和上面类似，DelayWorkQueue:一个使用优先级队列实现的无界阻塞队列，只有在延迟期满时才能从中提取元素，但是最大线程为Integer.MAX_VALUE，可以认为是无界大，可能会导致OOM。
    在这里插入图片描述
    上面4种Executors创建线程池使用的线程池工场也是默认的，也都不能指定拒绝策略，均使用默认的拒绝策略，即AbortPolicy

下面随便演示一个OOM

package com.threadpool;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

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

/**
 * @Author ll
 * @Description
 * @Date 1/3/22 10:00 PM
 **/
@SpringBootTest
@RunWith(SpringRunner.class)
public class ThreadPoolApplicationTest {

    @Test
    public void test(){
        ExecutorService executorService = Executors.newCachedThreadPool();
        int i = 0;
        while (true) {
            executorService.submit(new MyTask(i++));
        }

    }

    class MyTask implements Runnable{

        private int i;

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

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

运行结果如下
在这里插入图片描述

4、线程池中处理任务优先级

先判断核心线程是否创建满了，核心线程没满就核心线程处理，核心线程创建满了阻塞队列没满就放到阻塞队列里，阻塞队列也满了看最大线程数是否满了，最大线程数没满就创建线程处理，最大线程数也创建满了就按照自己定义的拒绝策略执行了。
在这里插入图片描述

5、线程池核心数的配置

一般需要根据任务的类型来配置线程池大小：
如果是CPU密集型任务，参考值可以设为 核心数+1
如果是IO密集型任务，参考值可以设置为2*核心数
Java获取线程池核心数

System.out.println(Runtime.getRuntime().availableProcessors());

在这里插入图片描述

参考链接
https://juejin.cn/post/6844903889678893063
https://juejin.cn/post/6844903560623161352
https://blog.csdn.net/xiaojin21cen/article/details/87269126
https://developer.huawei.com/consumer/cn/forum/topic/0202438478344770295

小火柴66
关注
  • 5
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
在线程池中创建多少线程比较合理？
01-20
在设置线程池线程个数的时候，经常会想到这个问题，是不是设置的线程数越多越好？理解这个问题之前我们要先清楚的知道我们为什么使用多线程。 为什么会使用多线程 使用多线程的主要目的我们应该都能回答的出来就是提高程序的性能，这个提高性能其实是指 降低延迟 （发送请求到接收到数据的时间）和 提高吞吐量 （单位时间能可以处理更多的请求）。 降低延迟和提高吞吐量对应的方法有两种: 优化算法 和 将机器的硬件性能发挥到极致  优化算法：降低时间和空间复杂度，使得程序执行时间更短。  将硬件的性能发挥到极致，具体的指提高I/O 和cpu的利用率 如何提高I/O 和cpu的利用率的举例： 如果单核系统中 只有
面试总被问，创建多少个线程合适？真的越多越好吗
我不生产数据，只是数据的搬运工
05-27 6540
码农小光关注 72020.04.18 00:04:50字数 3,178阅读 9,004 来源公众号：于日拱一兵 作者：tan日拱一兵 你有一个思想，我有一个思想，我们交换后，一个人就有两个思想 If you can NOT explain it simply, you do NOT understand it well enough image 为什么要使用多线程？ 防止并发编程出错最好的办法就是不写并发程序 image 既然多线程编程容易出错，为什么它还经久不...
Java 多线程与线程池 Thread弊端与Executor存在问题 及解决方法
小鹅鹅的博客
02-24 5473
文章目录Java 多线程与线程池 Thread弊端与Executor存在问题 及解决方法1. 使用Thread弊端2. 线程池背景及优势3. Executor解析3.1 线程池原理3.2 配置线程池3.3 优雅关闭线程池4. Executor存在问题解决方法5. Ref Java 多线程与线程池 Thread弊端与Executor存在问题 及解决方法 1. 使用Thread弊端 new Threa...
合理选择线程池大小
积
04-24 1427
在看这个问题之前一定要明白的是线程(应用程序)是不能控制CPU的计算资源分配的。他只是将任务提交给操作系统，至于CPU资源如何分配是由操作系统来控制的。对于多线程下的解决方案，并不是线程量越多就越好，线程池数量的设置要考虑到很多方面，首先要确认这个线程池所处理的任务是属于CPU密集型还是IO密集型或者属于混合型。对于CPU密集型一般线程池数量为CPU核数+1，+的这个1是充分利用CPU(如当某个线...
线程越多越好吗？
weixin_42935902的博客
10-06 8826
package SJMS; public class Test1 { public static void main(String[] args) { for (int i = 0; i < 10000000; i++) { new Thread(new Runnable() { public void run() { try { Thre...
深入理解Java 线程池
08-18
深入理解Java线程池 Java 线程池是 Java 编程中一个非常重要的概念，它可以帮助开发者更好地管理和控制线程的执行，提高系统的性能和效率。在 Java 中，线程池是通过 Executor 框架来实现的，Executor 框架提供了...
深入理解Java线程池：ThreadPoolExecutor _ Idea Buffer1
08-03
1. RUNNING ：能接受新提交的任务，并且也能处理阻塞队列中的任务 2. SHUTDOWN：关闭状态，不再接受新提交的任务，但却可以继续处理阻塞队列中已保
深入理解Java线程池（PPT：原理+代码）
04-11
通过剖析Java中线程池的原理，解读Java线程池源码，并给出线程池调用的示例，帮助理解线程池的基本原理。
深入理解Java之线程池
12-22
在前面的文章中，我们...我们来详细讲解一下Java的线程池，首先我们从核心的ThreadPoolExecutor类中的方法讲起，然后再讲述它的实现原理，接着给出了它的使用示例，后讨论了一下如何合理配置线程池的大小。 　以下是
深入理解Java编程线程池的实现原理
08-28
主要介绍了深入理解Java编程线程池的实现原理，涉及ThreadPoolExecutor类，线程池实现原理及示例等相关内容，具有一定参考价值，需要的朋友可以了解下。
线程池的基本原理和使用
nerowpt的博客
03-15 444
线程池的基本原理和使用线程是否越多越好线程池的基本概念关于ScheduledThreadPoolExecutorJ.U.C线程池的简单使用通过Executors创建线程池 线程是否越多越好 线程在java中是一个对象，更是操作系统的资源，线程的创建、销毁都需要时间。如果创建+销毁时间&amp;amp;gt;线程任务的执行时间，创建该线程就会很不合算。 java对象占用堆内存，操作系统线程占用系统内存，根据jvm规...
java线程是不是越多越好_10|Java线程（中）：创建多少线程才是合适的？
weixin_28937075的博客
02-28 1403
在 Java 领域，实现并发程序的主要手段就是多线程，使用多线程还是比较简单的，但是使用多个线程却是个困难的问题，工作中，经常有人问，“各种线程池的线程数量调整成多少是合适的？”或者“Tomcat 的线程数、Jdbc 连接池的连接数是多少？”等等。那我们应该如何设置合适的线程数呢？要解决这个问题，首先要分析以下两个问题：1、为什么要使用多线程2、多线程的应用场景有哪些为什么要使用多线程？使用多线程...
线程池大小设置多少比较合适？
最新发布
旷野历程
12-04 1623
旨在用公式描述在并行计算中，多核处理器理论上能够提高多少倍速度。它代表了处理器并行运算之后效率提升的能力。公式如下：S(N)：是加速比（Speedup）P：是并行化部分占总程序执行时间的比例N：是并行化部分的处理器数目P 为并行计算所占比例，N 为并行节点处理个数。当 1 - P = 0 时，没有串行，只有并行，最大加速比 S(N) = N；当 P = 0 时，只有串行，没有并行，最小加速比 S(N) = 1；
深入理解线程池
香烟，瓜子，矿泉水
06-05 279
什么是线程池 线程是一种昂贵的资源，其主要开销分为以下几个方面： 线程的创建和启动的开销 线程销毁的开销 线程调度的开销。线程的调度会导致上下文切换，从而增了了处理器资源的消耗 因此，我们需要一种有效的使用线程的方式，线程池就是一种常见的方式。 线程池的优势 降低创建线程和销毁线程的性能开销 提高响应速度，当有新任务需要执行是不需要等待线程创建就可以立马执行 合理的设置线程池大小可以避免因为线程数超过硬件资源瓶颈带来的问题 线程池的使用 线程池在java中是如何实现的呢？ 在 JDK 1.5 之后推
Java线程：创建多少线程才是合适的？
ChinaLiaoTian的博客
12-28 4106
Java多线程实战，创建多少线程才是合适的？
Java多线程引发的性能问题以及调优策略
热门推荐
落枫寒的博客
11-21 4万+
本文主要介绍了Java多线程引发的性能问题以及调优策略，包括对线程同步、线程池、以及伪共享所引发的问题，并提出了相应的解决方法...
线程池线程数过多引起的问题
m0_37133375的博客
08-05 6512
1.创建更多的线程会消耗更多的内存（这个大家都知道）； 2.线程数过多，会引起频繁的线程上下文切换。那么，这个该怎么理解呢？我会结合以下代码给大家举一个例子。 synchronized (this.getClass()){ doSomething(); } 假如，现在服务器只有一个cpu，有3个线程a,b,c，并发执行这段代码。a抢到锁时，bc还没有真正的阻塞，因为bc不知道a抢到锁了。那么，...
C++多线程多少个线程算多？
10-25 6499
程序一启动就创建了60个线程，太多了，应该控制一下。也有同学提出不同意见，说线程多不是问题，别把它当成指标，盯住内存、CPU才是正经。使用多线程，为的是提高执行效率；那么，是不是线程越多越好呢？ 假设我们有100个下载任务，我们可以有以下3种实现方法： 使用一个线程，依次执行100个下载任务； 使用100个线程，每个线程执行一个下载任务； 使用10个线程，每个线程依次执行10个下载任务。 ...
java多线程深入理解
06-13
Java多线程是Java语言中的一项非常重要的特性，它允许程序同时执行多个任务。多线程可以提高程序的并发性和性能，但是也带来了一些挑战，如线程安全、死锁、资源竞争等问题。 Java多线程的实现方式有两种：继承Thread类和实现Runnable接口。继承Thread类需要重写run()方法，该方法中包含线程需要执行的代码。实现Runnable接口需要实现run()方法，但是需要将Runnable对象传递给Thread类的构造方法中。 Java多线程的核心概念包括线程优先级、线程同步、线程通信、线程池等。线程优先级可以通过设置Thread类的setPriority()方法来进行设置，但是并不保证优先级高的线程一定会先执行。线程同步可以通过关键字synchronized来实现，它可以保证同一时刻只有一个线程可以访问共享资源。线程通信可以通过wait()、notify()、notifyAll()等方法来实现，它可以使线程之间进行协作。线程池可以通过Executor框架来实现，它可以实现线程的复用，减少线程创建和销毁的开销。 在使用Java多线程时，需要避免一些常见的问题，如死锁、资源竞争、线程安全等。死锁会导致线程之间相互等待，无法进行下去；资源竞争会导致多个线程同时访问共享资源，可能会导致数据的不一致；线程安全问题会导致多个线程同时访问共享资源，可能会导致数据的不一致或者程序崩溃等问题。 综上所述，Java多线程是一项非常重要的特性，它可以提高程序的并发性和性能，但是在使用时需要注意一些常见的问题。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值