java创建线程池一共有七种方式

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

java创建线程池一共有七种方式

这 7 种实现方法分别是:

Executors.newFixedThreadPool:创建一个固定大小的线程池,可控制并发的线程数,超出的线程会在队列中等待。
Executors.newCachedThreadPool:创建一个可缓存的线程池,若线程数超过处理所需,缓存一段时间后会回收,若线程数不够,则新建线程。
Executors.newSingleThreadExecutor:创建单个线程数的线程池,它可以保证先进先出的执行顺序。
Executors.newScheduledThreadPool:创建一个可以执行延迟任务的线程池。
Executors.newSingleThreadScheduledExecutor:创建一个单线程的可以执行延迟任务的线程池。
Executors.newWorkStealingPool:创建一个抢占式执行的线程池(任务执行顺序不确定)【JDK 1.8 添加】。
ThreadPoolExecutor:手动创建线程池的方式,它创建时最多可以设置 7 个参数。

一、用ExecutorService创建线程池

//1.创建一个大小为10的线程池
ExecutorService threadPool= Executors.newFixedThreadPool(10);
//给线程池添加任务
for (int i = 0;i < 10;i++){
    threadPool.submit(new Runnable() {
      @Override
      public synchronized void run(){
          //这里写你的方法
          log.info("开启线程..");
      }
  });
}

二、用ThreadPoolExecutor创建线程池

//1.创建一个大小为10的线程池
BlockingQueue queue = new LinkedBlockingQueue();
ThreadPoolExecutor executor= new ThreadPoolExecutor(10,Integer.MAX_VALUE,10L, TimeUnit.SECONDS,queue);
//给线程池添加任务
for (int i = 0;i < 10;i++){
executor.execute(new Runnable() {
    @Override
      public synchronized void run(){
          //这里写你的方法
          log.info("开启线程..");
      }
  });
}

从根本上说ExecutorService算是通过ThreadPoolExecutor封装出来的他们的底层其实是一样的

ThreadPoolExecutor需要传参,而ExecutorService有默认值,值需要一个线程数量就可以了。文章来源地址https://www.toymoban.com/news/detail-698953.html

三、用ThreadPoolUtils工具类创建线程池

import com.google.common.util.concurrent.ThreadFactoryBuilder;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.concurrent.*;

/**
 * 自定义线程创建工具类,创建线程池后不需要关闭
 *
 * @author liangxn
 */
public class ThreadPoolUtils {
    private static final Logger LOGGER = LoggerFactory.getLogger(ThreadPoolUtils.class);
    private static ThreadPoolExecutor threadPool = null;
    private static final String POOL_NAME = "myPool";
    // 等待队列长度
    private static final int BLOCKING_QUEUE_LENGTH = 1000;
    // 闲置线程存活时间
    private static final int KEEP_ALIVE_TIME = 5 * 1000;

    private ThreadPoolUtils() {
        throw new IllegalStateException("utility class");
    }


    /**
     * 无返回值直接执行
     *
     * @param runnable 需要运行的任务
     */
    public static void execute(Runnable runnable) {
        getThreadPool().execute(runnable);
    }

    /**
     * 有返回值执行
     * 主线程中使用Future.get()获取返回值时,会阻塞主线程,直到任务执行完毕
     *
     * @param callable 需要运行的任务
     */
    public static <T> Future<T> submit(Callable<T> callable) {
        return getThreadPool().submit(callable);
    }

    /**
     * 停止线程池所有任务
     * @return
     */
    public static synchronized void shutdownNow() {
        getThreadPool().shutdownNow();
    }

    /**
     * 获取线程池中活跃线程数
     * @return
     */
    public static int getActiveCount() {
        return getThreadPool().getActiveCount();
    }


    private static synchronized ThreadPoolExecutor getThreadPool() {
        if (threadPool == null) {
            // 获取处理器数量
            int cpuNum = Runtime.getRuntime().availableProcessors();
            // 根据cpu数量,计算出合理的线程并发数
            int maximumPoolSize = cpuNum * 2 + 1;
            // 核心线程数、最大线程数、闲置线程存活时间、时间单位、线程队列、线程工厂、当前线程数已经超过最大线程数时的异常处理策略
            threadPool = new ThreadPoolExecutor(maximumPoolSize - 1,
                    maximumPoolSize,
                    KEEP_ALIVE_TIME,
                    TimeUnit.MILLISECONDS,
                    new LinkedBlockingDeque<>(BLOCKING_QUEUE_LENGTH),
                    new ThreadFactoryBuilder().setNameFormat(POOL_NAME + "-%d").build(),
                    new ThreadPoolExecutor.AbortPolicy() {
                        @Override
                        public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
                            LOGGER.warn("线程爆炸了,当前运行线程总数:{},活动线程数:{}。等待队列已满,等待运行任务数:{}",
                                    e.getPoolSize(),
                                    e.getActiveCount(),
                                    e.getQueue().size());
                        }
                    });

        }
        return threadPool;
    }
}

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

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

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

相关文章

  • Java多线程 - 创建的三种方式介绍

    什么是线程 ? 线程(thread)是一个程序内部的一条执行路径。 我们之前启动程序执行后,main方法的执行其实就是一条单独的执行路径。 程序中如果只有一条执行路径,那么这个程序就是单线程的程序。 什么是多线程 ? 多线程是指从软硬件上实现多条执行流程的技术。 方式一

    2024年02月20日
    浏览(45)
  • java创建多线程的7种方式---代码详解

    运行结果如下: 可以看出,主线程是不需要等待子线程执行完再执行下面的程序,主线程执行完了子线程还在执行,因此,子线程报错是不会影响主线程的。 运行结果: 运行结果: 运行结果: callable和future现成可以获取到返回的结果,底层是基于LockSupport,从JDK5就提供了C

    2024年02月15日
    浏览(55)
  • 【面试精讲】Java线程6种状态和工作原理详解,Java创建线程的4种方式

    Java线程6种状态和工作原理详解,Java创建线程的4种方式 一、Java线程的六种状态 二、Java线程是如何工作的? 三、BLOCKED 和 WAITING 的区别 四、start() 和 run() 源码分析 五、Java创建线程的所有方式和代码详解 1. 继承Thread类 2. 实现Runnable接口 3. 实现Callable接口与FutureTask 4. 使用线

    2024年03月13日
    浏览(50)
  • 【Java面试题】线程创建的三种方式及区别?

    继承Thread类,子类重写run()方法,调用子类的strat()启动线程。 实现Runnable接口,实现run()方法,调用对象start()启动线程。 实现Callable接口,实现call()方法,用FutureTask()封装实现类。使用FutureTask对象作为Thread对象调用start()启动线程,调用FutureTask对象的get()

    2024年02月12日
    浏览(50)
  • 大家都说Java有三种创建线程的方式!并发编程中的惊天骗局!

    在Java中,创建线程是一项非常重要的任务。线程是一种轻量级的子进程,可以并行执行,使得程序的执行效率得到提高。Java提供了多种方式来创建线程,但许多人都认为Java有三种创建线程的方式,它们分别是 继承Thread类、实现Runnable接口和使用线程池。 但是,你们知道吗?

    2024年02月08日
    浏览(71)
  • java中HashMap的七种遍历方式

    感兴趣的话大家可以关注一下公众号 : 猿人刘先生 , 欢迎大家一起学习 , 一起进步 , 一起来交流吧! HashMap的多种遍历方式从大体中归类 , 可以分为以下4类 : 迭代器(Iterator) For Each Lambda (JDK 1.8 +) Streams API (JDK 1.8 +) 但是每种方式又有不同的实现类型 : 使用迭代器(Iterator)En

    2023年04月09日
    浏览(38)
  • 创建线程的几种方式

    线程和进程的区别: 进程是操作系统进行资源分配的最小单元。 线程是操作系统进行任务分配的最小单元,线程隶属于进程。 如何开启线程? 1、继承Thread类,重写run方法。 2、实现Runnable接口,实现run方法。 3、实现Callable接口,实现call方法。通过FutureTask创建一个线程,获

    2024年02月03日
    浏览(57)
  • 线程创建的三种方式

    目录 1. Thread类 2. Runnable接口 3. Callable接口 4. 线程的生命周期 新建  就绪 运行 阻塞 等待 结束 继承Thread类的方式创建线程 定义Thread类的子类,并重写该类的run()方法,该run()方法的方法体就代表了线程需要完成的任务 创建Thread类的子类,即创建了线程对象 调用线程对象的

    2024年02月09日
    浏览(43)
  • 多线程-线程的创建的方式3、4:实现Callable与线程池

    简要概况: 案例: 输出: 现有问题: 如果并发的线程数量很多,并且每个线程都是执行一个时间很短的任务就结束了,这样频繁创建线程就会大大降低系统的效率,因为频繁创建线程和销毁线程需要时间。 那么,有没有一种办法使得线程可以复用,即执行完一个任务,并

    2024年02月09日
    浏览(45)
  • 创建多线程的四种方式

    ① 创建一个类继承 Thread 类,重写 run() 方法 ② 调用 start() 方法启动线程 例: ① 创建类实现 Runnable 接口,重写 run() 方法 ② 以实现类作为构造器参数,创建一个线程( Thread )对象 ③ 调用 start() 方法启动线程 例 注意:实现Runnable接口方式中,调用的不是Thread类的run()方法

    2024年02月10日
    浏览(49)

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

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

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

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

二维码1

领取红包

二维码2

领红包