Java創(chuàng)建線程池的幾種方式代碼示例
更新時間：2025年01月26日 08:29:54 作者：動物園首領
這篇文章主要介紹了Java中創(chuàng)建線程池的四種方式,包括使用Executors類、ThreadPoolExecutor類、Future和Callable接口以及Spring的ThreadPoolTaskExecutor,文中通過代碼介紹的非常詳細,需要的朋友可以參考下
一、創(chuàng)建線程池四種方式
- 使用 Executors 類，Executors 類是 Java 中用于創(chuàng)建線程池的工廠類，它提供了多種靜態(tài)方法來創(chuàng)建不同類型的線程池
- 使用 ThreadPoolExecutor 類，ThreadPoolExecutor 是 Java 中線程池的一個核心類，它提供了更細粒度的控制來創(chuàng)建和管理線程池
- 使用 Future 和 Callable，F(xiàn)uture 和 Callable 是并發(fā)編程中非常重要的兩個接口，它們通常與 ExecutorService 一起使用來執(zhí)行異步任務。
- 使用 Spring 的 ThreadPooltaskExecutor，ThreadPoolTaskExecutor 是一個基于 java.util.concurrent.ThreadPoolExecutor 的擴展，提供了更豐富的配置選項和與Spring集成的特性
二、線程池重要參數
- corePoolSize (int): 線程池的基本大小，即在沒有任務執(zhí)行時線程池的大小。當新任務提交時，線程池會優(yōu)先使用已有的空閑線程。
- maximumPoolSize (int): 線程池能夠容納同時執(zhí)行的最大線程數。這個參數用于控制線程池的最大規(guī)模，防止因任務過多而導致資源耗盡。
- keepAliveTime (long): 當線程池中的線程數量超過 corePoolSize 時，多余的空閑線程能等待新任務的最長時間。超過這個時間后，多余的線程將被終止。
- unit (TimeUnit): keepAliveTime 參數的時間單位，常見的時間單位有 TimeUnit.SECONDS、TimeUnit.MINUTES 等。
- workQueue (BlockingQueue): 一個阻塞隊列，用于存儲等待執(zhí)行的任務。常用的阻塞隊列有 LinkedBlockingQueue、ArrayBlockingQueue 和 SynchronousQueue 等。
- threadFactory (ThreadFactory): 用于創(chuàng)建新線程的工廠。可以通過實現(xiàn) ThreadFactory 接口來自定義線程的創(chuàng)建過程。
- handler (RejectedExecutionHandler): 當任務太多而線程池無法處理時，用于定義拒絕任務的策略。常見的拒絕策略有 ThreadPoolExecutor.AbortPolicy、ThreadPoolExecutor.CallerRunsPolicy 和 ThreadPoolExecutor.DiscardPolicy 等。
package com.demo.threadPool;
import java.util.concurrent.*;
public class MainDemo1 {
public static void main(String[] args) {
int corePoolSize = 5; // 核心線程數
int maximumPoolSize = 10; // 最大線程數
long keepAliveTime = 1; // 非核心線程空閑存活時間
/**
* 存活時間單位
* TimeUnit.DAYS：天
* TimeUnit.HOURS：小時
* TimeUnit.MINUTES：分
* TimeUnit.SECONDS：秒
* TimeUnit.MILLISECONDS：毫秒
* TimeUnit.MICROSECONDS：微妙
* TimeUnit.NANOSECONDS：納秒
*/
TimeUnit unit = TimeUnit.MINUTES;
BlockingQueue<Runnable> workQueue = new LinkedBlockingQueue<Runnable>(); // 工作隊列
ThreadFactory threadFactory = Executors.defaultThreadFactory(); // 線程工廠
RejectedExecutionHandler handler = new ThreadPoolExecutor.AbortPolicy(); // 拒絕策略
ThreadPoolExecutor executor = new ThreadPoolExecutor(corePoolSize,maximumPoolSize,keepAliveTime,unit,workQueue,threadFactory,handler);
}
}
三、線程池5種狀態(tài)
- RUNNING：正常運行狀態(tài)，可接收新任務，可處理阻塞隊列中的任務
- SHUTDOWN：不會接收新任務，但會處理阻塞隊列剩余任務
- STOP：會中斷正在執(zhí)行的任務，并拋棄阻塞隊列任務
- TIDYING：任務全執(zhí)行完畢，活動線程為 0，即將進入終結
- TERMINATED：終結狀態(tài)
四、Executors 類創(chuàng)建線程池
- new newCachedThreadPool()：創(chuàng)建一個可緩存線程池，如果線程池長度超過處理需要，可靈活回收空閑線程，若無可回收，則新建線程。線程池的規(guī)模不存在限制。（數量不固定的線程池）
- new newFixedThreadPool()：創(chuàng)建一個固定長度線程池，可控制線程最大并發(fā)數，超出的線程會在隊列中等待。（固定數量的線程池）
- new newScheduledThreadPool()：創(chuàng)建一個固定長度線程池，支持定時及周期性任務執(zhí)行。（定時線程池）
- new newSingleThreadExecutor()：創(chuàng)建一個單線程化的線程池，它只會用唯一的工作線程來執(zhí)行任務，保證所有任務按照指定順序(FIFO, LIFO, 優(yōu)先級)執(zhí)行。（單線程的線程池）
- 固定線程池創(chuàng)建 ( Executors.newFixedThreadPool(5) )：創(chuàng)建一個固定大小的線程池。線程池中的線程數量是固定的，即使有些線程處于空閑狀態(tài)，它們也不會被回收。
package com.demo.threadPool;
import java.util.List;
import java.util.concurrent.*;
public class MainThreadPool {
public static void main(String[] args) throws ExecutionException, InterruptedException {
//初始化固定大小線程池
ExecutorService executor1 = Executors.newFixedThreadPool(5);
//使用 execute(Runnable command) 方法提交一個不需要返回結果的任務，
// 或者使用submit(Callable<T> task) 方法提交一個需要返回結果的任務。
for (int i = 0; i < 10; i++) {
executor1.execute(new TaskR(i));
}
//使用 submit(Callable<T> task) 任務并獲取 Future
//使用 Future.get() 方法等待任務完成并獲取結果。這個方法會阻塞調用線程直到任務完成。
for (int i = 0; i < 10; i++) {
Future<String> future = executor1.submit(new TaskC(i));
System.out.println("線程返回結果 "+future.get());
}
// 當所有任務都執(zhí)行完畢，或者需要關閉線程池時，調用 shutdown() 方法。
// 這將等待正在執(zhí)行的任務完成，但不接收新任務。
executor1.shutdown();
//使用 shutdownNow() 方法嘗試立即停止所有正在執(zhí)行的任務，并返回等待執(zhí)行的任務列表
List<Runnable> notExecutedTasks = executor1.shutdownNow();
for(Runnable ls : notExecutedTasks){
System.out.println(ls);
}
//使用 awaitTermination() 方法等待線程池關閉，直到所有任務完成或超時。
boolean res = executor1.awaitTermination(60, TimeUnit.SECONDS);
System.out.println("執(zhí)行結果："+res);
}
}
/**
* 實現(xiàn) Runnable 接口
*/
class TaskR implements Runnable {
private int id;
public TaskR(int id) {
this.id = id;
}
public void run() {
System.out.println("TaskR " + id + " is running...");
}
}
/**
* 實現(xiàn) Callable 接口
* 有返回值
*/
class TaskC implements Callable {
private int id;
public TaskC(int id) {
this.id = id;
}
@Override
public Object call(){
System.out.println("TaskC " + id + " is running...");
return id+"--TaskC";
}
}
- 單線程池 (newSingleThreadExecutor):創(chuàng)建一個只有一個線程的線程池。即使有多個任務提交，它們也會被排隊，逐個由單個線程執(zhí)行
package com.demo.threadPool;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
/**
* 單線程池 (newSingleThreadExecutor):
* 創(chuàng)建一個只有一個線程的線程池。即使有多個任務提交，它們也會被排隊，逐個由單個線程執(zhí)行。
*/
public class MainOne {
public static void main(String[] args) throws ExecutionException, InterruptedException {
/**
* 單線程：創(chuàng)建的執(zhí)行服務內部有一個線程。所有提交給它的任務將會序列化執(zhí)行，也就是說，它會在單個線程上依次執(zhí)行任務，不會有并發(fā)執(zhí)行的情況發(fā)生
* 任務隊列：如果有多個任務提交給這個執(zhí)行器，除了當前正在執(zhí)行的任務外，其他任務將會在一個無界隊列中等待，直到線程可用
* 處理任務失敗：如果執(zhí)行中的線程由于任務拋出異常而終止，執(zhí)行服務會安排一個新的線程來替換它，以繼續(xù)執(zhí)行后續(xù)的任務
* 使用場景： newSingleThreadExecutor 非常適合需要順序執(zhí)行的任務，并且要求任務之間不受并發(fā)問題影響的場景
*/
ExecutorService executor = Executors.newSingleThreadExecutor();
for (int i = 0; i < 10; i++) {
executor.execute(new TaskR(i));
}
//使用 submit(Callable<T> task) 任務并獲取 Future
//使用 Future.get() 方法等待任務完成并獲取結果。這個方法會阻塞調用線程直到任務完成。
for (int i = 0; i < 10; i++) {
Future<String> future = executor.submit(new TaskC(i));
System.out.println("線程返回結果 "+future.get());
}
// 當所有任務都執(zhí)行完畢，或者需要關閉線程池時，調用 shutdown() 方法。
// 這將等待正在執(zhí)行的任務完成，但不接收新任務。
executor.shutdown();
}
}
- 緩存線程池 (newCachedThreadPool):創(chuàng)建一個可根據需要創(chuàng)建新線程的線程池。如果線程空閑超過60秒，它們將被終止并從池中移除
package com.demo.threadPool;
import java.util.Date;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/**
* 緩存線程池 (newCachedThreadPool):
* 創(chuàng)建一個可根據需要創(chuàng)建新線程的線程池。如果線程空閑超過60秒，它們將被終止并從池中移除
*/
public class MainCacheThreadPool {
public static void main(String[] args) throws InterruptedException {
System.out.println(Thread.currentThread().getName() + "線程: Start at: " + new Date());
//初始化緩存線程池
ExecutorService exec = Executors.newCachedThreadPool();
for (int i = 1; i < 10; i++) {
System.out.println("添加了第" + i + "個任務類");
Thread.sleep(2000);
exec.execute(new TaskR(i));
}
//所有任務結束后關閉線程池
exec.shutdown();
System.out.println(Thread.currentThread().getName() + " 線程: Finished all threads at：" + new Date());
}
}
- 調度線程池 (newScheduledThreadPool):創(chuàng)建一個支持定時任務和周期性任務的線程池
package com.demo.threadPool;
import java.util.Date;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
/**
* 固定頻率執(zhí)行
* 調度線程池 (newScheduledThreadPool):
* 創(chuàng)建一個支持定時任務和周期性任務的線程池
*/
public class MainScheduledThreadPool {
public static void main(String[] args) {
/**
* 場景描述
* 假設你需要一個應用程序，該程序能夠每10秒執(zhí)行一次任務，并在啟動后1分鐘開始執(zhí)行。此外，
* 你還需要能夠安排一次性任務在未來的某個時間點執(zhí)行
*/
ScheduledExecutorService threadPool = Executors.newScheduledThreadPool(10);
// 安排定期任務
// 初始延遲1分鐘，之后每10秒執(zhí)行一次
threadPool.scheduleAtFixedRate(new TaskR(2), 60, 10, TimeUnit.SECONDS);
// 安排一次性任務
// 使用 schedule 方法安排一個任務，在指定的延遲后執(zhí)行一次
// 延遲5分鐘后執(zhí)行
threadPool.schedule(new TaskR(3), 5, TimeUnit.MINUTES);
// 關閉線程池
// 當不再需要線程池時，調用 shutdown 方法來關閉線程池。這將等待正在執(zhí)行的任務完成，但不接收新任務
threadPool.shutdown();
// 等待線程池關閉
// 使用 awaitTermination 方法等待線程池關閉，直到所有任務完成或超時。
try {
threadPool.awaitTermination(1, TimeUnit.HOURS);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
- 使用給定的線程工廠創(chuàng)建線程池:可以提供一個自定義的 ThreadFactory 來創(chuàng)建線程池中的線程
package com.demo.threadPool;
import java.util.concurrent.*;
/**
* 使用給定的線程工廠創(chuàng)建線程池
*/
public class MainFactory {
public static void main(String[] args) {
//自定義線程工廠創(chuàng)建
ThreadFactory threadFactory = new ThreadFactory() {
@Override
public Thread newThread(Runnable r) {
return new Thread(r);
}
};
//使用給定的線程工廠創(chuàng)建線程池
ExecutorService executor = Executors.newFixedThreadPool(5, threadFactory);
executor.execute(new TaskR(2));
}
}
- 自定義線程工廠創(chuàng)建：自定義線程工廠可以設置自己的線程名，設置守護線程，設置線程優(yōu)先級，處理未捕獲的異常等
package com.demo.threadPool;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.atomic.AtomicInteger;
/**
* 自定義線程工廠：設置線程名，守護線程，優(yōu)先級以及UncaughtExceptionHandler
*/
public class MainFactory implements ThreadFactory {
private final ThreadGroup group;
private final AtomicInteger threadNumber = new AtomicInteger(1);
private final String namePrefix;
public MainFactory(String namePrefix) {
SecurityManager s = System.getSecurityManager();
group = (s != null) ? s.getThreadGroup() : Thread.currentThread().getThreadGroup();
this.namePrefix = namePrefix + "-thread-";
}
public MainFactory(ThreadGroup group, String namePrefix) {
this.group = group;
this.namePrefix = namePrefix;
}
@Override
public Thread newThread(Runnable r) {
Thread t = new Thread(group, r,namePrefix + threadNumber.getAndIncrement(),0);
//守護線程
if (t.isDaemon())
t.setDaemon(true);
//線程優(yōu)先級
if (t.getPriority() != Thread.NORM_PRIORITY)
t.setPriority(Thread.NORM_PRIORITY);
/**
* 處理未捕捉的異常
*/
t.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
@Override
public void uncaughtException(Thread t, Throwable e) {
System.out.println("處理未捕獲的異常");
}
});
return t;
}
//測試方法
public static void main(String[] args) {
ExecutorService pool = Executors.newFixedThreadPool(5, new MainFactory("測試線程"));
for (int i = 0; i < 10; i++) {
pool.execute(new Runnable() {
@Override
public void run() {
System.out.println("線程處理");
//未捕獲的異常，走自定義的UncaughtExceptionHandler邏輯
int i = 1 / 0;
}
});
}
pool.shutdown();
}
}
五、ThreadPoolExecutor 類創(chuàng)建線程池
ThreadPoolExecutor 是 java.util.concurrent 包中用來創(chuàng)建線程池的一個類。它提供了一種靈活的方式來管理線程池，允許你控制線程的創(chuàng)建和銷毀。
ThreadPoolExecutor 類中的幾個重要方法
- execute()：向線程池提交一個任務，交由線程池去執(zhí)行
- submit()：也是向線程池提交任務，但是和execute()方法不同，它能夠返回任務執(zhí)行的結果它實際上還是調用的 execute() 方法，只不過它利用了 Future 來獲取任務執(zhí)行結果
- invokeAll()：提交一個任務集合
- invokeAny()： 提交一個任務集合，哪個任務先成功執(zhí)行完畢，返回此任務執(zhí)行結果，其它任務取消
- shutdown()：關閉線程池，再也不會接受新的任務不會立即終止線程池，而是要等所有任務緩存隊列中的任務都執(zhí)行完后才終止
- shutdownNow()：關閉線程池，再也不會接受新的任務立即終止線程池，并嘗試打斷正在執(zhí)行的任務，并且清空任務緩存隊列，返回尚未執(zhí)行的任務
- isShutdown()：不在 RUNNING 狀態(tài)的線程池，此方法就返回 true
- isTerminated()：線程池狀態(tài)是否是 TERMINATED
package com.demo.threadPool;
import java.util.Random;
import java.util.concurrent.*;
/**
* ThreadPoolExecutor 是 java.util.concurrent 包中用來創(chuàng)建線程池的一個類
* 它提供了一種靈活的方式來管理線程池，允許你控制線程的創(chuàng)建和銷毀。
* 以下是幾種常見的創(chuàng)建 ThreadPoolExecutor 線程池的方式
* 實際上 Executors 類也是調用 ThreadPoolExecutor 類創(chuàng)建的線程
*/
public class MainThreadPoolExecutor {
//測試方法
public static void main(String[] args) {
/**
* 核心線程數，核心線程就是一直存在的線程
*/
int corePoolSize = 5;
/**
* 最大線程數，表示線程池中最多能創(chuàng)建多少個線程
* 非核心線程數 = 最大線程數 - 核心線程數
*/
int maximumPoolSize = 10;
/**
* 默認情況下，只有當線程池中的線程數大于corePoolSize時，
* keepAliveTime才會起作用,則會終止，直到線程池中的線程數不超過corePoolSize
* 則會終止，直到線程池中的線程數不超過corePoolSize
* 但是如果調用了 allowCoreThreadTimeOut(boolean) 方法
* 在線程池中的線程數不大于corePoolSize時，keepAliveTime參數也會起作用,直到線程池中的線程數為 0
* 針對非核心線程而言，表示線程沒有任務執(zhí)行時最多保持多久時間會終止
*/
long keepAliveTime = 60;
/**
* 時間單位
* 與 keepAliveTime 配合使用，針對非核心線程
*/
TimeUnit unit = TimeUnit.SECONDS;
/**
* 存放任務的阻塞隊列
*/
BlockingQueue<Runnable> workQueue = new LinkedBlockingQueue<>(5);
/**
* 創(chuàng)建線程的工廠，可以為線程創(chuàng)建時起個好名字
*/
ThreadFactory threadFactory = new ThreadFactory() {
@Override
public Thread newThread(Runnable r) {
return new Thread(r);
}
};
/**
* 拒絕策略
* 任務太多的時候會進行拒絕操作
* 核心線程，非核心線程，任務隊列都放不下時
*/
// 自定義拒絕策略
RejectedExecutionHandler defaultHandler1 = new MyRejectedExecutionHandler();
// 默認策略，在需要拒絕任務時拋出RejectedExecutionException
RejectedExecutionHandler defaultHandler3 = new ThreadPoolExecutor.AbortPolicy();
// 直接在 execute 方法的調用線程中運行被拒絕的任務，如果線程池已經關閉，任務將被丟棄；
RejectedExecutionHandler defaultHandler2 = new ThreadPoolExecutor.CallerRunsPolicy();
// 直接丟棄任務
RejectedExecutionHandler defaultHandler4 = new ThreadPoolExecutor.DiscardPolicy();
// 丟棄隊列中等待時間最長的任務，并執(zhí)行當前提交的任務，如果線程池已經關閉，任務將被丟棄
RejectedExecutionHandler defaultHandler5 = new ThreadPoolExecutor.DiscardOldestPolicy();
/**
* 創(chuàng)建線程池
*/
ExecutorService service1 = new ThreadPoolExecutor( corePoolSize, maximumPoolSize,keepAliveTime,
unit,workQueue,threadFactory,defaultHandler1);
for (int i = 0; i < 10; i++) {
System.out.println("添加第"+i+"個任務");
service1.execute(new MyThread("線程"+i));
}
service1.shutdown();
}
}
/**
* 自定義拒絕策略
*/
class MyRejectedExecutionHandler implements RejectedExecutionHandler {
@Override
public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
new Thread(r,"新線程"+new Random().nextInt(10)).start();
}
}
/**
* 線程類
*/
class MyThread implements Runnable {
String name;
public MyThread(String name) {
this.name = name;
}
@Override
public void run() {
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("線程:"+Thread.currentThread().getName() +" 執(zhí)行:"+name +" run");
}
}
六、Future 和 Callable 類使用創(chuàng)建線程池
- Callable 是一個函數式接口，它允許你定義一個任務，該任務可以返回一個結果并拋出異常。它是 Runnable 接口的擴展，增加了返回值和拋出異常的能力。
- 返回值：與 Runnable 接口不同，Callable 任務可以返回一個值，返回值通過 Future 對象獲取。
- 異常：Callable 任務可以拋出異常，這些異?？梢酝ㄟ^ Future 對象處理。
- Future 接口代表異步計算的結果。它提供了檢查計算是否完成的方法，以及獲取計算結果的方法。
- get()：獲取計算結果。如果計算尚未完成，此方法會阻塞，直到計算完成或拋出異常。
- isDone()：檢查計算是否完成。
- cancel()：嘗試取消任務。
- isCancelled()：檢查任務是否被取消
package com.demo.threadPool;
import java.util.concurrent.*;
/**
* Future 使用
*/
public class MainFuture {
public static void main(String[] args) throws ExecutionException, InterruptedException {
ExecutorService executorService = Executors.newFixedThreadPool(1);
System.out.println("開始時間戳為:" + System.currentTimeMillis());
Future<String> future = executorService.submit(new Test01());
String result = future.get(); //獲取計算結果。如果計算尚未完成，此方法會阻塞，直到計算完成或拋出異常
boolean isdone = future.isDone(); //檢查計算是否完成
boolean cancel = future.cancel(true); //嘗試取消任務
boolean iscancelled = future.isCancelled(); //檢查任務是否被取消
System.out.println("result："+result);
System.out.println("isdone："+isdone);
System.out.println("cancel："+cancel);
System.out.println("iscancelled："+iscancelled);
System.out.println("結束時間戳為:" + System.currentTimeMillis());
executorService.shutdown();
}
}
class Test01 implements Callable {
@Override
public Object call() throws Exception {
return "你好";
}
}
七、Spring 的 ThreadPoolTaskExecutor 類創(chuàng)建線程池
ThreadPoolTaskExecutor 是 Spring 框架提供的一個線程池實現(xiàn)，它擴展了 Java 的 ThreadPoolExecutor 并提供了一些額外的配置和功能
- 添加依賴： 如果你的項目是一個 Maven 項目，確保你的 pom.xml 文件中包含了 Spring Boot 的依賴
- 配置線程池： 在 Spring Boot 應用程序中，你可以通過 Java 配置類來配置 ThreadPoolTaskExecutor
package com.cnpc.epai.assetcatalog.dmp.controller;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
import java.util.concurrent.ThreadPoolExecutor;
/**
* 線程池配置類
*/
@Configuration
public class ConfigPoolConfiguration {
@Bean("TaskExecutorDemo")
public ThreadPoolTaskExecutor taskExecutorDemo(){
ThreadPoolTaskExecutor threadPoolTaskExecutor = new ThreadPoolTaskExecutor();
threadPoolTaskExecutor.setCorePoolSize(10); // 核心線程數
threadPoolTaskExecutor.setMaxPoolSize(20);// 最大線程數
threadPoolTaskExecutor.setQueueCapacity(100); //工作隊列
threadPoolTaskExecutor.setKeepAliveSeconds(60); // 非核心線程的空閑存活時間
threadPoolTaskExecutor.setAllowCoreThreadTimeOut(true);//指定是否允許核心線程超時。這允許動態(tài)增長和收縮，即使與非零隊列結合使用也是如此（因為最大池大小只有在隊列已滿時才會增長）
threadPoolTaskExecutor.setThreadNamePrefix("monitor-thread-pool-");// 設置線程名前綴
threadPoolTaskExecutor.setRejectedExecutionHandler(new ThreadPoolExecutor.AbortPolicy());// 拒絕策略
threadPoolTaskExecutor.setWaitForTasksToCompleteOnShutdown(true);// 設置線程池關閉時需要等待子任務執(zhí)行完畢，才銷毀對應的bean
threadPoolTaskExecutor.initialize();//初始化線程池
return threadPoolTaskExecutor;
}
}
測試類
package com.cnpc.epai.assetcatalog.dmp.controller;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.annotation.Async;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
import org.springframework.stereotype.Service;
@Service
public class TestService {
@Autowired
private ThreadPoolTaskExecutor taskExecutor;
@Async("taskExecutor")
public void executeTask() {
taskExecutor.execute(() -> {
System.out.println("Executing task in thread: " + Thread.currentThread().getName());
});
}
}總結
到此這篇關于Java創(chuàng)建線程池的幾種方式的文章就介紹到這了,更多相關Java創(chuàng)建線程池方式內容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關文章希望大家以后多多支持腳本之家！
相關文章
SpringBoot實現(xiàn)elasticsearch索引操作的代碼示例
這篇文章主要給大家介紹了SpringBoot如何實現(xiàn)elasticsearch 索引操作，文中有詳細的代碼示例，感興趣的同學可以參考閱讀下2023-07-07
這篇文章主要介紹了IntelliJ IDEA2020.3詳細安裝教程,本文通過圖文并茂的形式給大家介紹的非常詳細，對大家的學習或工作具有一定的參考借鑒價值，需要的朋友可以參考下2020-12-12
java swing 創(chuàng)建一個簡單的QQ界面教程
這篇文章主要介紹了java swing 創(chuàng)建一個簡單的QQ界面教程，具有很好的參考價值，希望對大家有所幫助。一起跟隨小編過來看看吧2020-09-09
String s = new String(''a '') 到底產生幾個對象
這篇文章主要介紹了String s = new String(" a ") 到底產生幾個對象，文中通過示例代碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值，需要的朋友們下面隨著小編來一起學習學習吧2020-05-05
IDEA多Module設置language level默認級別方式
文章介紹了在Java項目中遇到編譯錯誤,源發(fā)行版8需要目標發(fā)行版1.8的問題,并提供了兩種解決方案：通過在出現(xiàn)問題的module的pom文件中加入特定代碼,或者修改maven的setting.xml文件來全局設置languagelevel,作者為解決這個問題提供了個人經驗,并鼓勵讀者參考和支持2025-12-12
這篇文章主要介紹了Spring AOP 切面@Around注解的用法說明，具有很好的參考價值，希望對大家有所幫助。一起跟隨小編過來看看吧2021-02-02
本文介紹了如何在Spring Boot項目中進行Web開發(fā),包括創(chuàng)建項目、配置文件、添加依賴、控制層修改、測試效果以及在IDEA中進行配置的詳細步驟2025-01-01
解析springboot整合谷歌開源緩存框架Guava Cache原理
本文主要為大家解析了springboot整合谷歌開源緩存框架Guava Cache的原理以及在實際開發(fā)過程中的使用，附含源碼，有需要的朋友可以參考下2021-08-08
這篇文章主要介紹了使用FastJson進行駝峰下劃線相互轉換寫法及誤區(qū)，文中通過示例代碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值，需要的朋友們下面隨著小編來一起學習吧2023-01-01
這篇文章主要介紹了SpringBoot啟動yaml報錯的解決方案，具有很好的參考價值，希望對大家有所幫助。如有錯誤或未考慮完全的地方，望不吝賜教2021-08-08