Java 线程池 参数

这篇具有很好参考价值的文章主要介绍了Java 线程池 参数。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

1、为什么要使用线程池

线程池能有效管控线程,统一分配任务,优化资源使用。

2、线程池的参数

创建线程池,在构造一个新的线程池时,必须满足下面的条件:

corePoolSize(线程池基本大小)必须大于或等于0;
maximumPoolSize(线程池最大大小)必须大于或等于1;
maximumPoolSize必须大于或等于corePoolSize;
keepAliveTime(线程存活保持时间)必须大于或等于0;
workQueue(任务队列)不能为空;
threadFactory(线程工厂)不能为空,默认为DefaultThreadFactory类(可以通过线程工厂对不同线程池的线程名称进行设置,以区分产生bug的线程是哪个池的)
handler(线程饱和策略)不能为空,默认策略为ThreadPoolExecutor.AbortPolicy。

线程池参数围绕两个核心,线程任务

线程相关的参数:核心线程数,最大线程数,线程存活保持时间,线程饱和策略,线程工厂。

任务相关的参数:任务队列。

3、线程池执行过程

1、创建核心线程处理任务,失败则继续

2、将任务添加到任务队列

3、创建非核心线程处理任务

4、线程饱和策略

4、核心参数分析

4.1 任务队列

4.1.1 直接提交队列SynchronousQueue

设置为SynchronousQueue队列,SynchronousQueue是一个特殊的BlockingQueue,它没有容量,每执行一个插入操作就会阻塞。一般使用SynchronousQueue都会要求为无界(maximumPoolSize=Integer.MAX_VALUE)。

public class PoolTask implements Runnable{
    public int i;

    public int getI() {
        return i;
    }

    public void setI(int i) {
        this.i = i;
    }

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + " 正在执行 " + i + " 号任务");
    }

    public PoolTask(int i) {
        this.i = i;
    }
}
    public static void main(String[] args) {

        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(1, 2, 5000, TimeUnit.MILLISECONDS, new SynchronousQueue<>());
        for (int i = 0; i < 10; i++) {
            PoolTask poolTask = new PoolTask(i);
            threadPoolExecutor.execute(poolTask);
        }
        threadPoolExecutor.shutdown();

    }

执行结果:

Java 线程池 参数,java,开发语言,jvm


4.1.2 有界的任务队列ArrayBlockingQueue

一般使用ArrayBlockingQueue来实现。使用ArrayBlockingQueue有界任务队列,若有新的任务需要执行时,线程池会创建新的线程,直到创建的线程数量达到corePoolSize时,会将新的任务加入到等待队列中。这里等待队列的任务数量设置为2,若等待队列已满,即超过ArrayBlockingQueue初始化的容量,则继续创建线程,直到线程数量达到maximumPoolSize设置的最大线程数量,若大于maximumPoolSize,则执行拒绝策略。

    public static void main(String[] args) {

        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(1, 2, 5000, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<>(2));
        for (int i = 0; i < 10; i++) {
            PoolTask poolTask = new PoolTask(i);
            threadPoolExecutor.execute(poolTask);
        }
        threadPoolExecutor.shutdown();
    }

执行结果:

Java 线程池 参数,java,开发语言,jvm

4.1.3 无界的任务队列LinkedBlockingQueue

一般使用LinkedBlockingQueue来实现。使用无界的任务队列,线程池的任务队列可以无限制添加新任务,而线程池创建的最大线程数就是corePoolSize设置的数量,这种情况下maximumPoolSize设置的值是不会生效的,就算等待队列中有许多未执行的任务,线程池的数量达到了corePoolSize的值后也不会增加新的线程。

    public static void main(String[] args) {

        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(1, 2, 5000, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<>());
        for (int i = 0; i < 10; i++) {
            PoolTask poolTask = new PoolTask(i);
            threadPoolExecutor.execute(poolTask);
        }
        threadPoolExecutor.shutdown();
    }

运行结果:

Java 线程池 参数,java,开发语言,jvm


4.1.4 优先任务队列PriorityBlockingQueue

一般使用PriorityBlockingQueue来实现。任务需要实现comparable接口,根据任务的优先级执行任务。

public class PoolTask implements Runnable, Comparable<PoolTask>{
    public int i;

    public int getI() {
        return i;
    }

    public void setI(int i) {
        this.i = i;
    }

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + " 正在执行 " + i + " 号任务");
    }

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

    @Override
    public int compareTo(PoolTask o) {
        //升序排序
        return o.getI() - this.getI();
    }
}
    public static void main(String[] args) {

        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(1, 2, 5000, TimeUnit.MILLISECONDS, new PriorityBlockingQueue<>());
        for (int i = 0; i < 10; i++) {
            PoolTask poolTask = new PoolTask(i);
            threadPoolExecutor.execute(poolTask);
        }
        threadPoolExecutor.shutdown();
    }

运行结果:

Java 线程池 参数,java,开发语言,jvm

4.2 线程饱和策略

4.2.1 ThreadPoolExecutor.AbortPolicy

线程池默认的阻塞策略。不执行此任务,而且抛出一个运行时异常(未检查的异常RejectedExecutionException)。

切记:ThreadPoolExecutor.execute需要try catch,否则程序会直接退出。

ThreadPoolExecutor.DiscardPolicy

不执行此任务,而且不抛异常。(是个空方法)

public class PoolTask implements Runnable, Comparable<PoolTask>{
    public int i;

    public int getI() {
        return i;
    }

    public void setI(int i) {
        this.i = i;
    }

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + " 正在执行 " + i + " 号任务");
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

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

    @Override
    public int compareTo(PoolTask o) {
        //升序排序
        return o.getI() - this.getI();
    }
}
public class PoolTest {
    public static void main(String[] args) {
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(1, 2, 5000, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<>(2), Executors.defaultThreadFactory(), new ThreadPoolExecutor.AbortPolicy());
        for (int i = 0; i < 10; i++) {
            PoolTask poolTask = new PoolTask(i);
            try {
                threadPoolExecutor.execute(poolTask);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        threadPoolExecutor.shutdown();
    }
}

运行结果:

Java 线程池 参数,java,开发语言,jvm

4.2.2 ThreadPoolExecutor.DiscardOldestPolicy

从队列里删除最老的任务(头部的一个任务),并再次execute 此task。

public class PoolTest {
    public static void main(String[] args) {
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(1, 2, 5000, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<>(2), Executors.defaultThreadFactory(), new ThreadPoolExecutor.DiscardOldestPolicy());
        for (int i = 0; i < 10; i++) {
            PoolTask poolTask = new PoolTask(i);
            try {
                threadPoolExecutor.execute(poolTask);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        threadPoolExecutor.shutdown();
    }
}

运行结果:

Java 线程池 参数,java,开发语言,jvm

4.2.3 ThreadPoolExecutor.CallerRunsPolicy

让调用execute方法的线程执行此command,会阻塞入口。

这是个调节机制,既不抛弃任务也不抛出异常,而是将某些任务回退到调用者,让调用者所在的线程去执行。

public class PoolTest {
    public static void main(String[] args) {
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(1, 2, 5000, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<>(2), Executors.defaultThreadFactory(), new ThreadPoolExecutor.CallerRunsPolicy());
        for (int i = 0; i < 10; i++) {
            PoolTask poolTask = new PoolTask(i);
            try {
                threadPoolExecutor.execute(poolTask);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        threadPoolExecutor.shutdown();
    }
}

运行结果:

Java 线程池 参数,java,开发语言,jvm

4.2.4 用户自定义拒绝策略(最常用)

实现RejectedExecutionHandler,并自己定义策略模式

package com.example.dyc.mythreadpool;

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.RejectedExecutionHandler;
import java.util.concurrent.ThreadPoolExecutor;

public class MyThreadPolicy implements RejectedExecutionHandler {
    @Override
    public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
        if (r instanceof PoolTask){
            PoolTask poolTask = (PoolTask) r;
            if (poolTask.getI() != 6){
                return;
            }
            System.out.println("获取到六号任务,试图放入队列");
            BlockingQueue<Runnable> queue = executor.getQueue();
            while (true) {
                if (queue.remainingCapacity() > 0) {
                    queue.add(poolTask);
                    System.out.println("放入队列成功");
                    break;
                } else {
                    try {
                        System.out.println("放入队列失败,继续试图放入");
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }

        }
    }
}
public class PoolTest {
    public static void main(String[] args) {
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(1, 2, 5000, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<>(2), Executors.defaultThreadFactory(), new MyThreadPolicy());
        for (int i = 0; i < 10; i++) {
            PoolTask poolTask = new PoolTask(i);
            try {
                threadPoolExecutor.execute(poolTask);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        threadPoolExecutor.shutdown();
    }
}

运行结果:

Java 线程池 参数,java,开发语言,jvm

5 常用线程池类型

java通过Executors提供四种线程池,分别为:

5.1 newCachedThreadPool


newCachedThreadPool创建一个可缓存的无界线程池,如果线程池长度超过处理需要,可灵活回收空线程,若无可回收,则新建线程。当线程池中的线程空闲时间超过60s,则会自动回收该线程,当任务超过线程池的线程数则创建新的线程,线程池的大小上限为Integer.MAX_VALUE,可看作无限大。

5.2 newFixedThreadPool


newFixedThreadPool创建一个指定大小的线程池,可控制线程的最大并发数,超出的线程会在LinkedBlockingQueue阻塞队列中等待。

5.3 newScheduledThreadPool

newScheduledThreadPool线程池支持定时以及周期性执行任务,创建一个corePoolSize为传入参数,最大线程数为整形的最大数的线程池

5.4 newSingleThreadExecutor


newSingleThreadExecutor创建一个单线程化的线程池,它只有一个线程,用仅有的一个线程来执行任务,保证所有的任务按照指定顺序(FIFO,LIFO,优先级)执行,所有的任务都保存在队列LinkedBlockingQueue中,等待唯一的单线程来执行任务。文章来源地址https://www.toymoban.com/news/detail-846721.html

到了这里,关于Java 线程池 参数的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • Java 线程池 参数

    线程池能有效管控线程,统一分配任务,优化资源使用。 创建线程池,在构造一个新的线程池时,必须满足下面的条件: corePoolSize(线程池基本大小) 必须大于或等于0; maximumPoolSize(线程池最大大小) 必须大于或等于1; maximumPoolSize必须大于或等于corePoolSize; keepAliveTim

    2024年04月10日
    浏览(25)
  • [Java SE] 彻底搞懂Java程序的三大参数配置途径:系统变量与JVM参数(VM Option)/环境变量/启动程序参数args

    一次没搞懂,处处受影响。这个问题属于基础问题,但又经常踩坑,不得不重视一下了。 IDEA中的配置位置 参数 使用方式 示例 代码获取方式 系统属性 由操作系统、JVM、应用程序主动设置 System.setProperties(Properties propes) / System.setProperties(String key,String value) / System.getProperties(

    2024年02月08日
    浏览(41)
  • 线程方法接收参数和返回参数,Java的两种线程实现方式对比

    总所周知,Java实现多线程有两种方式,分别是继承Thread类和实现Runable接口,那么它们的区别是什么? 继承 Thread 类: 通过继承 Thread 类,你可以创建一个直接表示线程的类。你可以覆盖 Thread 类中的 run 方法来定义线程的逻辑。当调用 start 方法启动线程时,会执行该类中的

    2024年02月11日
    浏览(42)
  • 在Maven中设置JVM系统参数及Java应用调试实例

    在进行Java应用程序开发时,我们通常需要配置Maven构建过程中Java虚拟机(JVM)的额外系统参数,以便进行性能优化、日志配置或远程调试等操作。本文将详细介绍如何在Maven中设置JVM系统参数,并通过一个具体的Java应用远程调试示例来演示这一过程。 Maven使用环境变量 MAVE

    2024年01月23日
    浏览(42)
  • Java多线程之线程池的参数和配置

    在Java多线程编程中,线程池是一种常见的技术,用于管理线程的创建和销毁。线程池中的线程可以被重复利用,从而减少了线程的创建和销毁的开销,提高了程序的性能。在Java中,线程池的参数和配置非常重要,不同的参数和配置会影响线程池的性能和行为。 Java线程池的主

    2024年02月16日
    浏览(38)
  • 线程方法接收参数示例,Java的两种线程实现方式区别

    总所周知,Java实现多线程有两种方式,分别是继承Thread类和实现Runable接口,那么它们的区别是什么? 继承 Thread 类: 通过继承 Thread 类,你可以创建一个直接表示线程的类。你可以覆盖 Thread 类中的 run 方法来定义线程的逻辑。当调用 start 方法启动线程时,会执行该类中的

    2024年02月11日
    浏览(41)
  • java语法(二)线程并发、Juit单元测试、反射机制、注解、动态代理、XML解析、JVM

    正则表达式验证网站 1、 ? :表示前边这个字符可以出现0次或者1次。例如下边 /used? 既可以匹配 use 也可以匹配 used 。 2、 * :匹配0个或者多个字符, * 号代表前边这个字符可以出现0次或者多次。例如 /ab*c 可以匹配 ac、abc、abbbbc 3、 + :与 * 号不同的是, + 需要前面这个字符

    2024年02月06日
    浏览(49)
  • TOMCAT部署及优化(Tomcat配置文件参数优化,Java虚拟机(JVM)调优)

    TOMCAT tomcat :是一个开放源代码的web应用服务器,基于java代码开发的。也可以理解为tomacat就是处理动态请求和基于java代码的页面开发。可以在html当中写入java代码,tomcat可以解析html页面当中的java,执行动态请求,动态页面。 tomcat是机制存在一些问题,如果不对tomcat进行优化

    2024年02月13日
    浏览(31)
  • 【JVM故障问题排查心得】「Java技术体系方向」Java虚拟机内存优化之虚拟机参数调优原理介绍

    本文主要针对于综合层面上进行分析JVM优化方案总结和列举调优参数计划。主要包含: 调优之逃逸分析(栈上分配) 调优之线程局部缓存(TLAB) 调优之G1回收器 -XX:+DoEscapeAnalysis 逃逸分析(Escape Analysis) 逃逸分析的基本行为就是分析对象动态作用域:当一个对象在方法中被定

    2024年01月25日
    浏览(59)
  • Java线上故障排查(CPU、磁盘、内存、网络、GC)+JVM性能调优监控工具+JVM常用参数和命令

    根据服务部署和项目架构,从如下几个方面排查: (1)运用服务器:排查内存,cpu,请求数等; (2)文件图片服务器:排查内存,cpu,请求数等; (3)计时器服务器:排查内存,cpu,请求数等; (4)redis服务器:排查内存,cpu,连接数等; (5)db服务器:排查内存,cpu,连接数

    2024年02月07日
    浏览(61)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包