Bootstrap

java常用线程池

常用线程池介绍

        1:FixedThreadPool（固定大小线程池)

                特点：线程池中的线程数量在创建时就被设定，并且是固定的。当有新的任务提交到线程池时，如果线程池中有空闲线程，则立即执行；若所有线程都在工作，则新任务会被放入队列中等待。
                使用场景：适用于处理大量短生命周期的任务，且系统资源有限或者要求任务的响应时间较为稳定的情况。

        2:CachedThreadPool（缓存型线程池)

                特点：线程池会根据需要创建新的线程，理论上可以无限制地增长，同时它还试图回收并重用之前已经终止的线程，以减少创建新线程带来的性能开销。
                使用场景：适合于处理大量耗时较短、并发量较大的任务，但需要注意控制系统的负载，防止由于线程过多而导致系统资源耗尽。

        3:ScheduledThreadPool（定时线程池）

                特点：主要用于执行定时任务和周期性任务，它同样是一个定长线程池，但在处理定时任务方面提供额外的功能支持。
                使用场景：例如定期执行清理任务、数据统计等操作。

        4:SingleThreadExecutor（单一线程池）

                特点：线程池中只有一个线程来执行所有的任务，任务之间按照提交顺序进行串行执行。
                使用场景：对于那些要求任务严格按照顺序执行，不允许SingleThreadScheduledExecutor**（单一定并发的情况非常适用。

        5:ScheduledThreadPool

                特点：它是 ScheduledThreadPool 的特殊形式，只包含一个线程，用于按计划顺序执行定时任务。

        创建方式

                这些线程池均基于 java.util.concurrent 包下的 ThreadPoolExecutor 类以及相关的工厂类如Executors 创建。使用时可以根据具体需求选择合适的线程池类型来优化程序的并发性能。

使用示例

        1:FixedThreadPool示例

package org.springblade.test;

import lombok.extern.slf4j.Slf4j;
import org.apache.poi.ss.formula.functions.T;
import org.springblade.modules.gzfw.entity.GzfwYqjdEntity;
import org.springblade.modules.system.service.IDsfSjCcService;
import org.springblade.modules.system.service.impl.DsfSjCcServiceImpl;

import javax.annotation.Resource;
import java.lang.reflect.Field;
import java.sql.*;
import java.util.*;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;

@Slf4j
public class FixedThreadPoolTest {

    @org.junit.jupiter.api.Test
    public void fixedThreadPoolExample() {
        // 创建一个固定大小为5的线程池
        ExecutorService executorService = Executors.newFixedThreadPool(5);
        for (int i = 0; i < 5; i++){
            Runnable worker = new WorkerThread("" + i);
            executorService.execute(worker);
        }
        executorService.shutdown();
         // 关闭线程池，不再接受新任务并等待所有已提交的任务完成
        while (!executorService.isTerminated()){
        }
        System.out.println("所有任务已完成");
    }

}

class WorkerThread implements Runnable {
    private String command;

    public WorkerThread(String s) {
        this.command = s;
    }

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + " 开始执行任务: " + command);
    }
}


    //执行结果
    //pool-1-thread-1 开始执行任务: 0
    // pool-1-thread-2 开始执行任务: 1
    // pool-1-thread-4 开始执行任务: 3
    // pool-1-thread-3 开始执行任务: 2
    // pool-1-thread-5 开始执行任务: 4
    // 所有任务已完成

        2:CachedThreadPool示例

package org.springblade.test;

import lombok.extern.slf4j.Slf4j;
import org.apache.poi.ss.formula.functions.T;
import org.springblade.modules.gzfw.entity.GzfwYqjdEntity;
import org.springblade.modules.system.service.IDsfSjCcService;
import org.springblade.modules.system.service.impl.DsfSjCcServiceImpl;

import javax.annotation.Resource;
import java.lang.reflect.Field;
import java.sql.*;
import java.util.*;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;

@Slf4j
public class CachedThreadPoolTest {

    @org.junit.jupiter.api.Test
    public void cachedThreadPoolExample() {
        // 创建一个可以缓存线程并根据需要创建新线程的线程池
        ExecutorService executor = Executors.newCachedThreadPool();
        for (int i = 0; i < 10; i++) {
            Runnable worker = new WorkerThread("" + i);
            executor.execute(worker);
        }
        // 关闭线程池，不再接受新任务并尝试终止所有正在运行的任务
        executor.shutdown();
        while (!executor.isTerminated()) {
        }
        System.out.println("所有任务已完成");
    }
}


class WorkerThread implements Runnable {
    private String command;

    public WorkerThread(String s) {
        this.command = s;
    }

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + " 开始执行任务: " + command);
    }
}

    //执行结果
    //pool-1-thread-2 开始执行任务: 1
    // pool-1-thread-1 开始执行任务: 0
    // pool-1-thread-4 开始执行任务: 3
    // pool-1-thread-3 开始执行任务: 2
    // pool-1-thread-5 开始执行任务: 4
    // pool-1-thread-6 开始执行任务: 5
    // pool-1-thread-7 开始执行任务: 6
    // pool-1-thread-8 开始执行任务: 7
    // pool-1-thread-9 开始执行任务: 8
    // pool-1-thread-10 开始执行任务: 9
    // 所有任务已完成

        3:ScheduledThreadPool 示例

package org.springblade.test;

import lombok.extern.slf4j.Slf4j;

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

@Slf4j
public class ScheduledThreadPool Test {

    @org.junit.jupiter.api.Test
    public void scheduledThreadPool Example() {
        // 创建一个定长的定时线程池，核心线程数为1
        ScheduledExecutorService executor = Executors.newScheduledThreadPool(1);
        // 提交一个周期性任务，每两秒执行一次
        executor.scheduleAtFixedRate(new Runnable() {
            public void run() {
                System.out.println("当前时间：" + System.currentTimeMillis());
            }
        }, 0, 2, TimeUnit.SECONDS);
        // 在6秒后关闭线程池（这将导致所有未执行的任务被取消）
        try {
            Thread.sleep(6000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        executor.shutdownNow();
    }
}
    //执行结果
    //当前时间：1709185507280
    // 当前时间：1709185509279
    // 当前时间：1709185511280

        4:SingleThreadExecutor 示例

package org.springblade.test;

import lombok.extern.slf4j.Slf4j;

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

@Slf4j
public class SingleThreadExecutor Test {

    @org.junit.jupiter.api.Test
    public void singleThreadExecutorExample() {
        // 创建单一线程的线程池
        ExecutorService executor = Executors.newSingleThreadExecutor();
        for (int i = 0; i < 10; i++) {
            Runnable worker = new WorkerThread("" + i);
            executor.execute(worker);
        }
        // 关闭线程池
        executor.shutdown();
        while (!executor.isTerminated()) {
        }
        System.out.println("所有任务按顺序已完成");
    }
}

class WorkerThread implements Runnable {
    private String command;

    public WorkerThread(String s) {
        this.command = s;
    }

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + " 开始执行命令: " + command);
    }
}
//执行结果
// pool-1-thread-1 开始执行命令: 0
// pool-1-thread-1 开始执行命令: 1
// pool-1-thread-1 开始执行命令: 2
// pool-1-thread-1 开始执行命令: 3
// pool-1-thread-1 开始执行命令: 4
// pool-1-thread-1 开始执行命令: 5
// pool-1-thread-1 开始执行命令: 6
// pool-1-thread-1 开始执行命令: 7
// pool-1-thread-1 开始执行命令: 8
// pool-1-thread-1 开始执行命令: 9
// 所有任务按顺序已完成

        5:ScheduledThreadPool（定时调度线程池）

package org.springblade.test;

import lombok.extern.slf4j.Slf4j;

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

@Slf4j
public class ScheduledThreadPoolTest {

    @org.junit.jupiter.api.Test
    public void scheduledThreadPoolExample() {
        // 创建一个定长的定时线程池，核心线程数为1
        ScheduledExecutorService executor = Executors.newScheduledThreadPool(1);
        // 提交一个周期性任务，每两秒执行一次
        executor.scheduleAtFixedRate(new Runnable() {
            @Override
            public void run() {
                System.out.println("当前时间：" + System.currentTimeMillis());
            }
        }, 0, 2, TimeUnit.SECONDS);

        // 在一段时间后（例如6秒后）关闭线程池
        try {
            Thread.sleep(6000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        executor.shutdownNow();
    }
}

    //执行结果
    //当前时间：1709186336571
    //当前时间：1709186338571
    //当前时间：1709186340570
    //当前时间：1709186342570

悦读

道可道，非常道；名可名，非常名。 无名，天地之始，有名，万物之母。 故常无欲，以观其妙，常有欲，以观其徼。 此两者，同出而异名，同谓之玄，玄之又玄，众妙之门。

最新收录
C++知识点 —— 整合（持续更新中）
Django-xadmin使用指南
高并发场景实战: 线程池,countDownLatch,CompletableFuture混合使用
C03-Java同步实践加强班第8周上机任务
Stream和parallelStream
DVWA1.10_Brute_Force
FFmpeg--音频解码：aac解码为pcm实战
ipython的使用技巧整理
深入剖析Java项目中的线程安全问题
【Knox】Apache Knox 概述
;