AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

如何在 Java 8 中创建和使用线程池？

2024-07-08 102
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 【7月更文挑战第8天】

在 Java 8 中，线程池（Thread Pool）是一种管理线程资源的机制，能够有效地控制并发执行的线程数量，减少线程创建和销毁的开销，提高系统的性能。Java 提供了 java.util.concurrent 包，其中包含了一些用于创建和管理线程池的类和接口。本篇文章将详细介绍如何在 Java 8 中创建和使用线程池。

一、线程池的基本概念

1. 线程池的工作原理

线程池的基本原理是预先创建若干个线程，并将它们放入一个池中。应用程序提交的任务被放入一个队列中，线程池中的线程不断从队列中取出任务并执行。这样做有以下优点：

  1. 减少了线程创建和销毁的开销：线程的创建和销毁是昂贵的操作，使用线程池可以重用线程，减少这些开销。
  2. 提高了响应速度：由于线程已经存在，可以立即执行任务，减少了等待时间。
  3. 便于管理线程：可以通过配置线程池的大小，控制系统并发线程的数量，避免过多线程导致的资源耗尽问题。

2. 线程池的类型

Java 提供了几种常用的线程池：

  • FixedThreadPool：固定大小的线程池，线程数量不会改变。
  • CachedThreadPool：根据需要创建新线程的线程池，但在一定时间内未被使用的线程将被终止并移出缓存。
  • SingleThreadExecutor：单线程的线程池，所有任务将顺序执行。
  • ScheduledThreadPool：可以延迟或定期执行任务的线程池。

二、创建线程池

Java 8 中提供了 Executors 工具类来创建各种类型的线程池。

1. 创建固定大小的线程池

使用 Executors.newFixedThreadPool(int nThreads) 方法可以创建一个固定大小的线程池。

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

public class FixedThreadPoolExample {
   
   
    public static void main(String[] args) {
   
   
        ExecutorService executorService = Executors.newFixedThreadPool(5);

        for (int i = 0; i < 10; i++) {
   
   
            Runnable task = new Task(i);
            executorService.execute(task);
        }

        executorService.shutdown();
    }
}

class Task implements Runnable {
   
   
    private final int taskId;

    public Task(int taskId) {
   
   
        this.taskId = taskId;
    }

    @Override
    public void run() {
   
   
        System.out.println("Executing task " + taskId + " by " + Thread.currentThread().getName());
    }
}

在上述代码中，Executors.newFixedThreadPool(5) 创建了一个包含 5 个线程的线程池。通过 executorService.execute(task) 提交任务给线程池执行。

2. 创建缓存线程池

使用 Executors.newCachedThreadPool() 方法可以创建一个缓存线程池。

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

public class CachedThreadPoolExample {
   
   
    public static void main(String[] args) {
   
   
        ExecutorService executorService = Executors.newCachedThreadPool();

        for (int i = 0; i < 10; i++) {
   
   
            Runnable task = new Task(i);
            executorService.execute(task);
        }

        executorService.shutdown();
    }
}

class Task implements Runnable {
   
   
    private final int taskId;

    public Task(int taskId) {
   
   
        this.taskId = taskId;
    }

    @Override
    public void run() {
   
   
        System.out.println("Executing task " + taskId + " by " + Thread.currentThread().getName());
    }
}

Executors.newCachedThreadPool() 创建了一个缓存线程池，能够根据需要创建新线程。如果有空闲线程则重用它们，否则创建新的线程。

3. 创建单线程线程池

使用 Executors.newSingleThreadExecutor() 方法可以创建一个单线程线程池。

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

public class SingleThreadExecutorExample {
   
   
    public static void main(String[] args) {
   
   
        ExecutorService executorService = Executors.newSingleThreadExecutor();

        for (int i = 0; i < 10; i++) {
   
   
            Runnable task = new Task(i);
            executorService.execute(task);
        }

        executorService.shutdown();
    }
}

class Task implements Runnable {
   
   
    private final int taskId;

    public Task(int taskId) {
   
   
        this.taskId = taskId;
    }

    @Override
    public void run() {
   
   
        System.out.println("Executing task " + taskId + " by " + Thread.currentThread().getName());
    }
}

在上述代码中，Executors.newSingleThreadExecutor() 创建了一个单线程线程池，所有任务将顺序执行。

4. 创建调度线程池

使用 Executors.newScheduledThreadPool(int corePoolSize) 方法可以创建一个调度线程池。

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class ScheduledThreadPoolExample {
   
   
    public static void main(String[] args) {
   
   
        ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(5);

        Runnable task = new Task(1);
        scheduledExecutorService.schedule(task, 5, TimeUnit.SECONDS);

        scheduledExecutorService.shutdown();
    }
}

class Task implements Runnable {
   
   
    private final int taskId;

    public Task(int taskId) {
   
   
        this.taskId = taskId;
    }

    @Override
    public void run() {
   
   
        System.out.println("Executing task " + taskId + " by " + Thread.currentThread().getName());
    }
}

在上述代码中，Executors.newScheduledThreadPool(5) 创建了一个包含 5 个线程的调度线程池。scheduledExecutorService.schedule(task, 5, TimeUnit.SECONDS) 调度任务在 5 秒后执行。

三、线程池的配置

1. 自定义线程池

可以使用 ThreadPoolExecutor 类创建自定义线程池。该类提供了更多的配置选项，如核心线程数、最大线程数、空闲线程存活时间、任务队列等。

import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class CustomThreadPoolExample {
   
   
    public static void main(String[] args) {
   
   
        ThreadPoolExecutor executor = new ThreadPoolExecutor(
            5, 10, 60, TimeUnit.SECONDS, new LinkedBlockingQueue<Runnable>()
        );

        for (int i = 0; i < 20; i++) {
   
   
            Runnable task = new Task(i);
            executor.execute(task);
        }

        executor.shutdown();
    }
}

class Task implements Runnable {
   
   
    private final int taskId;

    public Task(int taskId) {
   
   
        this.taskId = taskId;
    }

    @Override
    public void run() {
   
   
        System.out.println("Executing task " + taskId + " by " + Thread.currentThread().getName());
    }
}

在上述代码中，ThreadPoolExecutor 的构造函数接受多个参数：

  • 核心线程数：保持在池中的线程数，即使它们处于空闲状态。
  • 最大线程数：池中允许的最大线程数。
  • 空闲线程存活时间：当线程数超过核心线程数时，多余的空闲线程存活的最长时间。
  • 时间单位：空闲线程存活时间的时间单位。
  • 任务队列：存放待执行任务的队列。

2. 配置拒绝策略

当线程池无法接受更多任务时，可以配置拒绝策略。常见的拒绝策略有：

  • AbortPolicy：直接抛出 RejectedExecutionException 异常。
  • CallerRunsPolicy：由调用线程处理该任务。
  • DiscardPolicy：直接丢弃任务，不予处理。
  • DiscardOldestPolicy：丢弃队列中最旧的任务，然后尝试提交新任务。
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.RejectedExecutionHandler;
import java.util.concurrent.ThreadPoolExecutor.AbortPolicy;

public class CustomThreadPoolWithRejectionPolicyExample {
   
   
    public static void main(String[] args) {
   
   
        RejectedExecutionHandler rejectionHandler = new AbortPolicy();

        ThreadPoolExecutor executor = new ThreadPoolExecutor(
            5, 10, 60, TimeUnit.SECONDS, new LinkedBlockingQueue<Runnable>(10), rejectionHandler
        );

        for (int i = 0; i < 30; i++) {
   
   
            Runnable task = new Task(i);
            executor.execute(task);
        }

        executor.shutdown();
    }
}

class Task implements Runnable {
   
   
    private final int taskId;

    public Task(int taskId) {
   
   
        this.taskId = taskId;
    }

    @Override
    public void run() {
   
   
        System.out.println("Executing task " + taskId + " by " + Thread.currentThread().getName());
    }
}

在上述代码中，使用 AbortPolicy 作为拒绝策略。当线程池和队列都满时，再提交

任务将抛出 RejectedExecutionException 异常。

四、线程池的管理和监控

1. 管理线程池

线程池的管理主要包括以下几个方面：

  • 关闭线程池：调用 shutdown() 或 shutdownNow() 方法关闭线程池。
    • shutdown()：平滑关闭，等待所有已提交的任务完成后关闭。
    • shutdownNow()：立即关闭，尝试中断正在执行的任务并返回未执行的任务列表。
executorService.shutdown();
// 或
executorService.shutdownNow();
  • 获取线程池状态：可以通过 isShutdown()、isTerminated() 方法获取线程池的状态。
if (executorService.isShutdown()) {
   
   
    System.out.println("ThreadPool is shutdown.");
}

if (executorService.isTerminated()) {
   
   
    System.out.println("All tasks are terminated.");
}

2. 监控线程池

可以通过 ThreadPoolExecutor 提供的方法获取线程池的运行状态：

  • getPoolSize()：返回当前线程池中的线程数。
  • getActiveCount()：返回正在执行任务的线程数。
  • getCompletedTaskCount()：返回已完成的任务数。
  • getTaskCount()：返回已提交的任务数。
ThreadPoolExecutor executor = (ThreadPoolExecutor) executorService;

System.out.println("Pool Size: " + executor.getPoolSize());
System.out.println("Active Threads: " + executor.getActiveCount());
System.out.println("Completed Tasks: " + executor.getCompletedTaskCount());
System.out.println("Total Tasks: " + executor.getTaskCount());

通过这些方法，可以实时监控线程池的运行情况，及时发现问题并进行调整。

五、示例：使用线程池进行并发编程

下面是一个完整的示例，展示了如何使用固定大小的线程池进行并发编程。

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

public class ThreadPoolExample {
   
   
    public static void main(String[] args) {
   
   
        // 创建固定大小的线程池
        ExecutorService executorService = Executors.newFixedThreadPool(5);

        // 提交任务
        for (int i = 0; i < 10; i++) {
   
   
            Runnable task = new Task(i);
            executorService.execute(task);
        }

        // 监控线程池状态
        ThreadPoolExecutor executor = (ThreadPoolExecutor) executorService;
        System.out.println("Pool Size: " + executor.getPoolSize());
        System.out.println("Active Threads: " + executor.getActiveCount());
        System.out.println("Completed Tasks: " + executor.getCompletedTaskCount());
        System.out.println("Total Tasks: " + executor.getTaskCount());

        // 关闭线程池
        executorService.shutdown();
    }
}

class Task implements Runnable {
   
   
    private final int taskId;

    public Task(int taskId) {
   
   
        this.taskId = taskId;
    }

    @Override
    public void run() {
   
   
        System.out.println("Executing task " + taskId + " by " + Thread.currentThread().getName());
        try {
   
   
            Thread.sleep(2000); // 模拟任务执行时间
        } catch (InterruptedException e) {
   
   
            Thread.currentThread().interrupt();
        }
        System.out.println("Completed task " + taskId + " by " + Thread.currentThread().getName());
    }
}

在这个示例中，创建了一个包含 5 个线程的固定大小的线程池，并提交了 10 个任务。通过监控线程池的状态，可以查看线程池的运行情况，并在所有任务完成后关闭线程池。

总结

本文详细介绍了如何在 Java 8 中创建和使用线程池。通过使用线程池，可以有效管理并发执行的线程数量，提高系统性能并降低资源消耗。Java 提供了多种类型的线程池，可以根据不同的应用场景选择合适的线程池。同时，可以通过自定义线程池和配置拒绝策略来满足特殊需求，并通过监控线程池的运行状态进行优化和调整。

文章标签：
Java
监控
调度
缓存
关键词：
Java线程
Java线程池
java8线程
wljslmz
目录
相关文章
yuanzhengme
|
7天前
|
安全 Java 调度
Java编程时多线程操作单核服务器可以不加锁吗？
Java编程时多线程操作单核服务器可以不加锁吗？
yuanzhengme
21 2
1176112968452250
|
11天前
|
存储 缓存 Java
java线程内存模型底层实现原理
java线程内存模型底层实现原理
1176112968452250
30 2
java线程内存模型底层实现原理
阿里云开发者
|
16天前
|
缓存 Java 应用服务中间件
Java虚拟线程探究与性能解析
本文主要介绍了阿里云在Java-虚拟-线程任务中的新进展和技术细节。
阿里云开发者
60 23
程序员小海绵
|
22天前
|
存储 缓存 安全
【Java面试题汇总】多线程、JUC、锁篇（2023版）
线程和进程的区别、CAS的ABA问题、AQS、哪些地方使用了CAS、怎么保证线程安全、线程同步方式、synchronized的用法及原理、Lock、volatile、线程的六个状态、ThreadLocal、线程通信方式、创建方式、两种创建线程池的方法、线程池设置合适的线程数、线程安全的集合？ConcurrentHashMap、JUC
程序员小海绵
43 3
【Java面试题汇总】多线程、JUC、锁篇（2023版）
请看我回答~
|
13天前
|
Java 开发者
Java中的多线程基础与应用
【9月更文挑战第22天】在Java的世界中，多线程是一块基石，它支撑着现代并发编程的大厦。本文将深入浅出地介绍Java中多线程的基本概念、创建方法以及常见的应用场景，帮助读者理解并掌握这一核心技术。
请看我回答~
18 5
杀死一只知更鸟debug
|
9天前
|
Java 调度
Java-Thread多线程的使用
这篇文章介绍了Java中Thread类多线程的创建、使用、生命周期、状态以及线程同步和死锁的概念和处理方法。
杀死一只知更鸟debug
9 0
Java-Thread多线程的使用
龙大吉
|
15天前
|
Java
领略Lock接口的风采，通过实战演练，让你迅速掌握这门高深武艺，成为Java多线程领域的武林盟主
领略Lock接口的风采，通过实战演练，让你迅速掌握这门高深武艺，成为Java多线程领域的武林盟主
龙大吉
23 7
游客qf4jmczx4xu2y
|
14天前
|
Java 程序员
Java中的多线程基础与实践
【9月更文挑战第21天】本文旨在引导读者深入理解Java多线程的核心概念，通过生动的比喻和实例，揭示线程创建、同步机制以及常见并发工具类的使用。文章将带领读者从理论到实践，逐步掌握如何在Java中高效地运用多线程技术。
游客qf4jmczx4xu2y
19 5
萝卜带泥
|
12天前
|
Java 调度 开发者
Java中的多线程编程：从基础到实践
本文旨在深入探讨Java多线程编程的核心概念和实际应用，通过浅显易懂的语言解释多线程的基本原理，并结合实例展示如何在Java中创建、控制和管理线程。我们将从简单的线程创建开始，逐步深入到线程同步、通信以及死锁问题的解决方案，最终通过具体的代码示例来加深理解。无论您是Java初学者还是希望提升多线程编程技能的开发者，本文都将为您提供有价值的见解和实用的技巧。
萝卜带泥
15 2
muxiaoxi
|
14天前
|
Java 数据处理
Java中的多线程编程：从基础到实践
本文旨在深入探讨Java中的多线程编程，涵盖其基本概念、创建方法、同步机制及实际应用。通过对多线程基础知识的介绍和具体示例的演示，希望帮助读者更好地理解和应用Java多线程编程，提高程序的效率和性能。
muxiaoxi
19 1

热门文章

最新文章

  • 1
    java.io.IOException: Stream closed解决办法
  • 2
    Java获取URL中的顶级域名domain的工具类
  • 3
    阿里Java代码规约插件即将全球首发，邀您来发布仪式现场
  • 4
    【Java核心技术卷】深入理解Java的内部类
  • 5
    《Java 7程序设计入门经典》一1.18　习题
  • 6
    Java创建透明与任意形状窗口
  • 7
    一道面试题考验了你对java的理解程度
  • 8
    Java内存模型
  • 9
    单链表_JAVA描述《数据结构与算法分析》
  • 10
    JAVA之旅（九）——Object类，equals，toString，getClass，内部类访问规则，静态内部类,内部类原则，匿名内部类
  • 1
    thread（线程）
    52
  • 2
    Java串口通信技术探究3：RXTX库线程 优化系统性能的SerialPortEventListener类
    488
  • 3
    JAVA难点包括异常处理、多线程、泛型和反射，以及复杂的分布式系统知识
    87
  • 4
    深入理解Java并发编程：线程安全与性能优化
    77
  • 5
    Java并发编程：深入理解线程池
    35
  • 6
    Redis 线程模型
    48
  • 7
    Java并发编程：深入理解线程池
    43
  • 8
    Java多线程编程实战：从入门到精通
    86
  • 9
    c++多线程——互斥锁
    61
  • 10
    【Flutter前端技术开发专栏】Flutter中的线程与并发编程实践
    173

    • 相关课程

    更多
  • Java面试疑难点解析 - 系统架构及项目设计
  • Java编程入门
  • Java面向对象编程
  • Java高级编程

    • 相关电子书

    更多
  • Spring Cloud Alibaba - 重新定义 Java Cloud-Native
  • The Reactive Cloud Native Arch
  • 多IO线程优化版

    • 相关实验场景

    更多
  • 基于ECS搭建Java Web开发环境
  • 使用Aliyun Java Intializr进行项目开发
  • 搭建Java Web开发环境
  • 部署基于Dragonwell的Java运行环境
  • 阿里云平台上进行Java程序的编译与运行
    • 下一篇
    无影云桌面