脚本之家 服务器常用软件
快捷导航
您的位置：首页 → 软件编程 → java → Java8创建和使用线程池

详解如何在Java8中创建和使用线程池

 更新时间：2024年06月14日 09:41:42   作者：wljslmz  
在 Java 8 中,线程池（Thread Pool）是一种管理线程资源的机制,能够有效地控制并发执行的线程数量,减少线程创建和销毁的开销,提高系统的性能,本篇文章将详细介绍如何在 Java 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 提供了多种类型的线程池，可以根据不同的应用场景选择合适的线程池。同时，可以通过自定义线程池和配置拒绝策略来满足特殊需求，并通过监控线程池的运行状态进行优化和调整。

以上就是详解如何在Java8中创建和使用线程池的详细内容，更多关于Java8创建和使用线程池的资料请关注脚本之家其它相关文章！

您可能感兴趣的文章:

相关文章

  • 浅谈spring.factories文件的作用

    浅谈spring.factories文件的作用

    本文主要介绍了浅谈spring.factories文件的作用,spring.factories文件是Spring Boot自动配置的核心文件之一,它的作用是将各种自动配置类与对应的配置类集中在一起,下面就来介绍一下如何使用,感兴趣的可以了解一下
    2024-06-06
  • java开发之File类详细使用方法介绍

    java开发之File类详细使用方法介绍

    这篇文章主要介绍了java开发之File类详细使用方法介绍,需要的朋友可以参考下
    2020-02-02
  • 货拉拉大数据对BitMap的探索实践详解

    货拉拉大数据对BitMap的探索实践详解

    这篇文章主要为大家介绍了货拉拉大数据对BitMap的探索实践详解，有需要的朋友可以借鉴参考下，希望能够有所帮助，祝大家多多进步，早日升职加薪
    2022-09-09
  • spring-mybatis获取mapper的四种方式汇总

    spring-mybatis获取mapper的四种方式汇总

    这篇文章主要介绍了spring-mybatis获取mapper的四种方式汇总，具有很好的参考价值，希望对大家有所帮助。如有错误或未考虑完全的地方，望不吝赐教
    2023-03-03
  • Java源码解析阻塞队列ArrayBlockingQueue常用方法

    Java源码解析阻塞队列ArrayBlockingQueue常用方法

    今天小编就为大家分享一篇关于Java源码解析阻塞队列ArrayBlockingQueue常用方法，小编觉得内容挺不错的，现在分享给大家，具有很好的参考价值，需要的朋友一起跟随小编来看看吧
    2019-01-01
  • Java线程生命周期的终止与复位

    Java线程生命周期的终止与复位

    这篇文章主要介绍了Java线程生命周期的终止与复位，Java的线程状态描述放在Thread类里面的枚举类State中.总共包含了6中状态，具体详情需要的小伙伴可以参考一下文章描述
    2022-07-07
  • Mybatis CachingExecutor二级缓存使用示例详解

    Mybatis CachingExecutor二级缓存使用示例详解

    这篇文章主要介绍了 Mybatis的CachingExecutor与二级缓存使用示例详解，有需要的朋友可以借鉴参考下，希望能够有所帮助，祝大家多多进步，早日升职加薪
    2023-09-09
  • Spring Boot使用和配置Druid

    Spring Boot使用和配置Druid

    本篇文章主要介绍了Spring Boot使用和配置Druid，Druid号称是Java语言中最好的数据库连接池，并且能够提供强大的监控和扩展功能
    2017-04-04
  • SpringBoot2中使用@RequestHeader获取请求头的方法

    SpringBoot2中使用@RequestHeader获取请求头的方法

    springMVC/SpringBoot中提供了@RequestHeader注解用来获取请求头。本文就详细的来介绍一下如何使用，感兴趣的可以了解下
    2021-10-10
  • SpringBoot对Jar包进行加密的示例代码

    SpringBoot对Jar包进行加密的示例代码

    在当今互联网高速发展的时代,软件安全问题变得尤为突出,随着开源技术的普及,Spring Boot等框架的应用越来越广泛,但也伴随着代码被反编译的风险,本文将探讨在Spring Boot项目中对Jar包进行加密,以防止反编译的安全实践,需要的朋友可以参考下
    2023-12-12

最新评论