详解Java线程池的使用(7种创建方法)

2024-10-02 20:55:33

1. 固定数量的线程池

public class ThreadPoolDemo3 {
    public static void main(String[] args) {
        ExecutorService threadPool = Executors.newFixedThreadPool(2);
        //添加任务方式 1
        threadPool.submit(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName());
            }
        });

        //添加任务方式2
        threadPool.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName());
            }
        });
    }
}
输出：
pool-1-thread-1
pool-1-thread-2

a. 线程池返回结果

public class ThreadPoolDemo4 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        ExecutorService threadPool =  Executors.newFixedThreadPool(2);
        //执行任务
        Future<Integer> result = threadPool.submit(new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
                int num = new Random().nextInt(10);
                System.out.println("随机数" + num);
                return num;
            }
        });

        //打印线程池返回方式
        System.out.println("返回结果：" + result.get());
    }
}
输出
随机数8
返回结果：8

使用submit可以执行有返回值的任务或者是无返回值的任务；而execute只能执行不带返回值的任务。

b. ⾃定义线程池名称或优先级

public class ThreadPoolDemo5 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
         // 创建线程工厂
        ThreadFactory threadFactory = new ThreadFactory() {
            @Override
            public Thread newThread(Runnable r) {
                //！！！！！！！一定要注意：要把任务Runnable设置给新创建的线程
                Thread thread = new Thread(r);
                //设置线程的命名规则
                thread.setName("我的线程" + r.hashCode());
                //设置线程的优先级
                thread.setPriority(Thread.MAX_PRIORITY);
                return thread;
            }
        };
        ExecutorService threadPool = Executors.newFixedThreadPool(2,threadFactory);
        //执行任务1
        Future<Integer> result = threadPool.submit(new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
                int num = new Random().nextInt(10);
                System.out.println(Thread.currentThread().getPriority() + ", 随机数：" + num);
                return num;
            }
        });
        //打印线程池返回结果
        System.out.println("返回结果：" + result.get());
    }
}

提供的功能：

1. 设置（线程池中）线程的命名规则。

2. 设置线程的优先级。

3. 设置线程分组。

4. 设置线程类型（用户线程、守护线程）。

2. 带缓存的线程池

public class ThreadPoolDemo6 {
    public static void main(String[] args) {
        //创建线程池
        ExecutorService service = Executors.newCachedThreadPool();
        for (int i = 0; i < 10; i++) {
            int finalI = i;
            service.submit(() -> {
                System.out.println("i : " + finalI + "|线程名称：" + Thread.currentThread().getName());
            });
        }
    }
}
输出
i : 1|线程名称：pool-1-thread-2
i : 4|线程名称：pool-1-thread-5
i : 3|线程名称：pool-1-thread-4
i : 5|线程名称：pool-1-thread-6
i : 0|线程名称：pool-1-thread-1
i : 2|线程名称：pool-1-thread-3
i : 6|线程名称：pool-1-thread-7
i : 7|线程名称：pool-1-thread-8
i : 8|线程名称：pool-1-thread-9
i : 9|线程名称：pool-1-thread-1

优点：线程池会根据任务数量创建线程池，并且在一定时间内可以重复使用这些线程，产生相应的线程池。

缺点：适用于短时间有大量任务的场景，它的缺点是可能会占用很多的资源。

3. 执⾏定时任务 a. 延迟执⾏(⼀次)

public class ThreadPoolDemo7 {
    public static void main(String[] args) {
        //创建线程池
        ScheduledExecutorService service = Executors.newScheduledThreadPool(5);
        System.out.println("添加任务的时间：" + LocalDateTime.now());
        //执行定时任务（延迟3s执行）只执行一次
        service.schedule(new Runnable() {
            @Override
            public void run() {
                System.out.println("执行子任务：" + LocalDateTime.now());
            }
        },3, TimeUnit.SECONDS);
    }
}
输出
添加任务的时间：2022-04-13T14:19:39.983
执行子任务：2022-04-13T14:19:42.987

b. 固定频率执⾏

public class ThreadPoolDemo8 {
    public static void main(String[] args) {
        //创建线程池
        ScheduledExecutorService service = Executors.newScheduledThreadPool(5);
        System.out.println("添加任务时间：" + LocalDateTime.now());
        //2s之后开始执行定时任务，定时任务每隔4s执行一次
        service.scheduleAtFixedRate(new Runnable() {
            @Override
            public void run() {
                System.out.println("执行任务：" + LocalDateTime.now());
            }
        },2,4, TimeUnit.SECONDS);
    }
}
输出
添加任务时间：2022-04-13T14:24:38.810
执行任务：2022-04-13T14:24:40.814
执行任务：2022-04-13T14:24:44.814
执行任务：2022-04-13T14:24:48.813
执行任务：2022-04-13T14:24:52.815
执行任务：2022-04-13T14:24:56.813
执行任务：2022-04-13T14:25:00.813
执行任务：2022-04-13T14:25:04.814
执行任务：2022-04-13T14:25:08.813
... ...
... ...
执行任务：2022-04-13T14:26:44.814
执行任务：2022-04-13T14:26:48.813

注意事项：

public class ThreadPoolDemo9 {
    public static void main(String[] args) {
        //创建线程池
        ScheduledExecutorService service = Executors.newScheduledThreadPool(5);
        System.out.println("添加任务时间：" + LocalDateTime.now());
        service.scheduleAtFixedRate(new Runnable() {
            @Override
            public void run() {
                System.out.println("执行任务： " + LocalDateTime.now());
                try {
                    Thread.sleep(5 * 1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },2,4, TimeUnit.SECONDS);
    }
}
输出
添加任务时间：2022-04-13T14:33:34.551
执行任务： 2022-04-13T14:33:36.556
执行任务： 2022-04-13T14:33:41.557
执行任务： 2022-04-13T14:33:46.559
执行任务： 2022-04-13T14:33:51.561
执行任务： 2022-04-13T14:33:56.562
执行任务： 2022-04-13T14:34:01.564
执行任务： 2022-04-13T14:34:06.566
执行任务： 2022-04-13T14:34:11.566
执行任务： 2022-04-13T14:34:16.567
执行任务： 2022-04-13T14:34:21.570
执行任务： 2022-04-13T14:34:26.570
... ....

c. scheduleAtFixedRate VS scheduleWithFixedDelay

scheduleAtFixedRate 是以上⼀次任务的开始时间，作为下次定时任务的参考时间的（参考时间+延迟任务=任务执⾏）。 scheduleWithFixedDelay 是以上⼀次任务的结束时间，作为下次定时任务的参考时间的。

public class ThreadPoolDemo10 {
    public static void main(String[] args) {
        //创建线程池
        ScheduledExecutorService service = Executors.newScheduledThreadPool(5);
        System.out.println("添加任务时间：" + LocalDateTime.now());
        //2s之后开始执行定时任务，定时任务每隔4s执行一次
        service.scheduleWithFixedDelay(new Runnable() {
            @Override
            public void run() {
                System.out.println("执行任务：" + LocalDateTime.now());
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, 2, 4, TimeUnit.SECONDS);
    }
}
输出
添加任务时间：2022-04-13T14:46:02.871
执行任务：2022-04-13T14:46:04.876
执行任务：2022-04-13T14:46:09.878
执行任务：2022-04-13T14:46:14.880
执行任务：2022-04-13T14:46:19.883
执行任务：2022-04-13T14:46:24.885
执行任务：2022-04-13T14:46:29.888
执行任务：2022-04-13T14:46:34.888
执行任务：2022-04-13T14:46:39.891
执行任务：2022-04-13T14:46:44.893
执行任务：2022-04-13T14:46:49.895
执行任务：2022-04-13T14:46:54.897
执行任务：2022-04-13T14:46:59.900
执行任务：2022-04-13T14:47:04.901
... ...

4. 定时任务单线程

public class ThreadPoolDemo11 {
    public static void main(String[] args) {
        ScheduledExecutorService service = Executors.newSingleThreadScheduledExecutor();
        System.out.println("添加任务的时间:" + LocalDateTime.now());
        service.schedule(new Runnable() {
            @Override
            public void run() {
                System.out.println("执行时间：" + LocalDateTime.now());
            }
        },2, TimeUnit.SECONDS );
    }
}
输出
添加任务的时间:2022-04-13T15:06:38.100
执行时间：2022-04-13T15:06:40.106

5. 单线程线程池

public class ThreadPoolDemo12 {
    public static void main(String[] args) {
        ExecutorService service = Executors.newSingleThreadScheduledExecutor();
        for (int i = 0; i < 10; i++) {
            service.submit(new Runnable() {
                @Override
                public void run() {
                    System.out.println("线程名：" + Thread.currentThread().getName());
                }
            });
        }
    }
}
输出
线程名：pool-1-thread-1
线程名：pool-1-thread-1
线程名：pool-1-thread-1
线程名：pool-1-thread-1
线程名：pool-1-thread-1
线程名：pool-1-thread-1
线程名：pool-1-thread-1
线程名：pool-1-thread-1
线程名：pool-1-thread-1
线程名：pool-1-thread-1

（MS）为什么不直接用线程？

单线程的线程池又什么意义？

1. 复用线程。

2. 单线程的线程池提供了任务队列和拒绝策略（当任务队列满了之后（Integer.MAX_VALUE），新来的任务就会拒绝策略）

6. 根据当前CPU⽣成线程池

public class ThreadPoolDemo13 {
    public static void main(String[] args) {
        ExecutorService service = Executors.newWorkStealingPool();
        for (int i = 0; i < 10; i++) {
            service.submit(() -> {
                System.out.println("线程名" + Thread.currentThread().getName());
            });

            while(!service.isTerminated()) {
            }
        }
    }
}
输出
线程名ForkJoinPool-1-worker-1

7. ThreadPoolExecutor

(1). Executors ⾃动创建线程池可能存在的问题

a. OOM 代码演示

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

public class ThreadPoolDemo54 {
    static class MyOOMClass {
        // 1M 空间（M KB Byte）
        private byte[] bytes = new byte[1 * 1024 * 1024];
   }
    public static void main(String[] args) throws InterruptedException {
        Thread.sleep(15 * 1000);
        ExecutorService service = Executors.newCachedThreadPool();
        Object[] objects = new Object[15];
        for (int i = 0; i < 15; i++) {
            final int finalI = i;
            service.execute(new Runnable() {
                @Override
                public void run() {
                    try {
                        Thread.sleep(finalI * 200);
                   } catch (InterruptedException e) {
                        e.printStackTrace();
                   }
                    MyOOMClass myOOMClass = new MyOOMClass();
                    objects[finalI] = myOOMClass;
                    System.out.println("任务：" + finalI);
               }
           });
       }
   }
}

执行结果：

b. 关于参数设置

-XX：标准设置，所有 HotSpot 都⽀持的参数。 -X：⾮标准设置，特定的 HotSpot 才⽀持的参数。 -D：程序参数设置，-D参数=value，程序中使⽤：System.getProperty("获取")。

mx 是 memory max 的简称

(2). ThreadPoolExecutor 使⽤

a. ThreadPoolExecutor 参数说明

b. 线程池执⾏流程

c. 执⾏流程验证

<MS>

线程池的重要执行节点：

1. 当任务来了之后，判断线程池中实际线程数是否小于核心线程数，如果小于就直接创建并执行任务。

2. 当实际线程数大于核心线程数（正式员工），他就会判断任务队列是否已满，如果未满就将任务存放队列即可。

3. 判断线程池的实际线程数是否大于最大线程数（正式员工 + 临时员工），如果小于最大线程数，直接创建线程执行任务；实际线程数已经等于最大线程数，则会直接执行拒绝策略。

d. 拒绝策略

（4种 JDK 提供的拒绝策略 + 1 种自定义拒绝策略）

Java ⾃带的拒绝策略，CallerRunsPolicy：

public class ThreadPoolDemo14 {
    public static void main(String[] args) {
        ThreadFactory factory = new ThreadFactory() {
            @Override
            public Thread newThread(Runnable r) {
                Thread thread = new Thread(r);
                return thread;
            }
        };
        // 手动创建线程池
        ThreadPoolExecutor executor = new ThreadPoolExecutor(1, 1, 100, TimeUnit.SECONDS, new LinkedBlockingDeque<>(1), new ThreadPoolExecutor.CallerRunsPolicy());
        for (int i = 0; i < 4; i++) {
            int finalI = i;
            executor.submit(() -> {
                System.out.println(Thread.currentThread().getName() + "执行任务：" + finalI);
            });
        }
        //终止线程
        executor.shutdown();
    }
}
输出
main执行任务：2
pool-1-thread-1执行任务：0
main执行任务：3
pool-1-thread-1执行任务：1

⾃定义拒绝策略：

线程状态

shutdown 执⾏时线程池终⽌接收新任务，并且会将任务队列中的任务处理完； shutdownNow 执⾏时线程池终⽌接收新任务，并且会给终⽌执⾏任务队列中的任务。

1. RUNNING：这个没什么好说的，这是最正常的状态：接受新的任务，处理等待队列中的任务； SHUTDOWN：不接受新的任务提交，但是会继续处理等待队列中的任务； 2. STOP：不接受新的任务提交，不再处理等待队列中的任务，中断正在执⾏任务的线程；

3. TIDYING：所有的任务都销毁了，workCount 为 0。线程池的状态在转换为 TIDYING 状态时，会执⾏钩⼦⽅法 terminated()；

4. TERMINATED：terminated() ⽅法结束后，线程池的状态就会变成这个。

到此这篇关于详解Java线程池的使用(7种创建方法)的文章就介绍到这了,更多相关Java线程池的使用内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们！

10分钟带你徒手写个Java线程池

目录 Java线程池核心原理手撸Java线程池定义核心字段创建内部类WordThread 创建ThreadPool类的构造方法创建执行任务的方法完整源码编写测试程序总结 Java线程池核心原理看过Java线程池源码的小伙伴都知道,在Java线程池中最核心的类就是ThreadPoolExecutor,而在ThreadPoolExecutor类中最核心的构造方法就是带有7个参数的构造方法,如下所示. public ThreadPoolExecutor(int corePoolSize
一文带你弄懂Java中线程池的原理

目录为什么要用线程池线程池的原理 ThreadPoolExecutor提供的构造方法 ThreadPoolExecutor的策略线程池主要的任务处理流程 ThreadPoolExecutor如何做到线程复用的四种常见的线程池 newCachedThreadPool newFixedThreadPool newSingleThreadExecutor newScheduledThreadPool 小结在工作中,我们经常使用线程池,但是你真的了解线程池的原理吗?同时,线程池工作原理和底层实
深入了解Java线程池的原理使用及性能优化

目录 1.什么是线程及线程池 1.1.为什么要使用线程 1.2.为什么要使用线程池 1.3.线程池的优点 2.线程池在java中的使用 2.1.线程池的工作原理 2.2.线程池的java代码示例 1.什么是线程及线程池线程是操作系统进行时序调度的基本单元. 线程池可以理解为一个存在线程的池子,就是一个容器,这个容器只能存在线程.这个容器有大小,可以放7,8个,也可以放3,4个.也可以把容器装满,但是都有一个最大值,比如说12个.比如说我这边线程池一般都装5个线程,最多能装12个.这个时候有五个
Java中线程池自定义实现详解

目录前言线程为什么不能多次调用start方法线程池到底是如何复用的前言最初使用线程池的时候,网上的文章告诉我说线程池可以线程复用,提高线程的创建效率.从此我的脑海中便为线程池打上了一个标签——线程池可以做到线程的复用.但是我总以为线程的复用是指在创建出来的线程可以多次的更换run()方法的内容,来达到线程复用的目的,于是我尝试了一下.同一个线程调用多次,然后使run的内容不一样,但是我发现我错了,一个线程第一次运行是没问题的,当再次调用start方法是会抛出异常(java.lang.I
Java实现手写线程池实例并测试详解

前言在之前的文章中介绍过线程池的核心原理,在一次面试中面试官让手写线程池,这块知识忘记的差不多了,因此本篇文章做一个回顾. 希望能够加深自己的印象以及帮助到其他的小伙伴儿们在线程池核心原理篇介绍过线程池的核心原理,今天来模拟线程池和工作队列的流程,以及编写代码和测试类进行测试.下面附下之前线程池的核心流程: 在线程池核心原理的源码中,涉及到了一系列的流程,包括线程池队列数量是否已满,运用什么样的拒绝策略等.在我们手写线程池的代码中,不需要考虑那么多因素,只需要模拟简单的情景和过程,因此整体来
详解Java线程池和Executor原理的分析

详解Java线程池和Executor原理的分析线程池作用与基本知识在开始之前,我们先来讨论下"线程池"这个概念."线程池",顾名思义就是一个线程缓存.它是一个或者多个线程的集合,用户可以把需要执行的任务简单地扔给线程池,而不用过多的纠结与执行的细节.那么线程池有哪些作用?或者说与直接用Thread相比,有什么优势?我简单总结了以下几点: 减小线程创建和销毁带来的消耗对于Java Thread的实现,我在前面的一篇blog中进行了分析.Java Thread与内
详解Java线程池的使用及工作原理

一.什么是线程池? 线程池是一种用于实现计算机程序并发执行的软件设计模式.线程池维护多个线程,等待由调度程序分配任务以并发执行,该模型提高了性能,并避免了由于为短期任务频繁创建和销毁线程而导致的执行延迟. 二.线程池要解决什么问题? 说到线程池就一定要从线程的生命周期讲起. 从图中可以了解无论任务执行多久,每个线程都要经历从生到死的状态.而使用线程池就是为了避免线程的重复创建,从而节省了线程的New至Runnable, Running至Terminated的时间:同时也会复用线程,最小化的节省系
详解Java线程池是如何重复利用空闲线程的

在Java开发中,经常需要创建线程去执行一些任务,实现起来也非常方便,但如果并发的线程数量很多,并且每个线程都是执行一个时间很短的任务就结束了,这样频繁创建线程就会大大降低系统的效率,因为频繁创建线程和销毁线程需要时间.此时,我们很自然会想到使用线程池来解决这个问题. 使用线程池的好处: 降低资源消耗.java中所有的池化技术都有一个好处,就是通过复用池中的对象,降低系统资源消耗.设想一下如果我们有n多个子任务需要执行,如果我们为每个子任务都创建一个执行线程,而创建线程的过程是需要一定的系统消耗
详解Java线程池如何实现优雅退出

目录 shutdown()方法 shutdownNow()方法 awaitTermination(long, TimeUnit)方法在[高并发专题]中,我们从源码角度深度分析了线程池中那些重要的接口和抽象类.深度解析了线程池是如何创建的,ThreadPoolExecutor类有哪些属性和内部类,以及它们对线程池的重要作用.深度分析了线程池的整体核心流程,以及如何拆解Worker线程的执行代码,深度解析Worker线程的执行流程. 本文,我们就来从源码角度深度解析线程池是如何优雅的退出程序的.首
详解Java线程池队列中的延迟队列DelayQueue

目录 DelayQueue延迟队列 DelayQueue使用场景 DelayQueue属性 DelayQueue构造方法实现Delayed接口使用示例 DelayQueue总结在阻塞队里中,除了对元素进行增加和删除外,我们可以把元素的删除做一个延迟的处理,即使用DelayQueue的方法.本文就来和大家聊聊Java线程池队列中的DelayQueue—延迟队列 public enum QueueTypeEnum { ARRAY_BLOCKING_QUEUE(1, "ArrayBlockingQ
详解Java线程池如何统计线程空闲时间

背景介绍你刚从学校毕业后,到新公司实习,试用期又被毕业,然后你又不得不出来面试,好在面试的时候碰到个美女面试官! 面试官: 小伙子,我看你简历上写的项目中用到了线程池,你知道线程池是怎样实现复用线程的? 这面试官是不是想坑我?是不是摆明了不让我通过? 难道你不应该问线程池有哪些核心参数?每个参数具体作用是什么? 往线程池中不断提交任务,线程池的处理流程是什么? 这些才是你应该问的,这些八股文我已经背熟了,你不问,瞎问什么复用线程? 幸亏我看了一灯的八股文,听我给你背一遍! 我: 线程池复用线程
详解Java线程池的增长过程

通过ThreadPoolExecutor的方式创建线程池 ThreadPoolExecutor 构造方法: public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, ThreadFactory threadFactory, RejectedExecutionHandler handle
java线程池ThreadPoolExecutor的八种拒绝策略示例详解

目录池化设计思想线程池触发拒绝策略的时机 JDK内置4种线程池拒绝策略拒绝策略接口定义 AbortPolicy(中止策略) DiscardPolicy(丢弃策略) DiscardOldestPolicy(弃老策略) 第三方实现的拒绝策略 Dubbo 中的线程拒绝策略 Netty 中的线程池拒绝策略 ActiveMQ 中的线程池拒绝策略 PinPoint 中的线程池拒绝策略谈到 Java 的线程池最熟悉的莫过于 ExecutorService 接口了,jdk1.5 新增的 java.uti
Java详解使用线程池处理任务方法

什么是线程池? 线程池就是一个可以复用线程的技术. 不使用线程池的问题: 如果用户每发起一个请求,后台就创建一个新线程来处理,下次新任务来了又要创建新线程,而创建新线程的开销是很大的,这样会严重影响系统的性能. 线程池常见面试题: 1.临时线程什么时候创建? 新任务提交时发现核心线程都在忙,任务队列也满了,并且还可以创建临时线程,此时才会创建临时线程. 2.什么时候会开始拒绝任务? 核心线程和临时线程都在忙,任务队列也满了,新的任务过来的时候才会开始任务拒绝. 1.线程池处理Runnable任务
详解Java线程同步器CountDownLatch

Java程序有的时候在主线程中会创建多个线程去执行任务,然后在主线程执行完毕之前,把所有线程的任务进行汇总,以前可以用线程的join方法,但是这个方法不够灵活,我们可以使用CountDownLatch类,实现更优雅,而且使用线程池的话,可没有办法调用线程的join方法的呀! 一.简单使用CountDownLatch 直接使用线程: package com.example.demo.study; import java.util.concurrent.CountDownLatch; public