java – Universeller Thread-Pool

Hintergrund:

        Vor kurzem habe ich in meiner Arbeit Thread-Pools verwendet, daher habe ich eine allgemeine Thread-Pool-Toolklasse geschrieben. Ich muss den Thread-Pool verwenden, um ihn später direkt wiederzuverwenden.

Code:

        

import lombok.extern.slf4j.Slf4j;
import java.util.concurrent.*;
/**
*   通用线程池
* */
@Slf4j
public class PushThreadPoolUtils {
    public static volatile ThreadPoolExecutor pool=null;


    private final static int CORE_POOL_SIZE =10 ;//核心线程数
    private final static int MAXIMUM_POOL_SIZE =50 ;//最大线程数
    private final static long KEEP_ALIVE_TIME =5 ;//非核心线程空闲时间
    private final static int MAXIMUM_WORK_QUEUE = 400;//消息队列最大任务数

    private PushThreadPoolUtils(){
        pool=new ThreadPoolExecutor(CORE_POOL_SIZE,// 1. 核心线程数
                MAXIMUM_POOL_SIZE,// 2. 最大线程数
                KEEP_ALIVE_TIME, // 3. 非核心线程空闲时间
                TimeUnit.SECONDS, // 4. 时间单位
                new ArrayBlockingQueue<>(MAXIMUM_WORK_QUEUE),// 5. 阻塞队列
                Executors.defaultThreadFactory(),// 6. 创建线程工厂
                new ThreadPoolExecutor.AbortPolicy());// 7. 拒绝策略
        log.info("PushThreadPoolUtils 线程池创建完成");
    }

    public static ThreadPoolExecutor getInstance(){
        //双重if单例
        if (null == pool){
            synchronized (PushThreadPoolUtils.class){
                if (pool == null){
                    new PushThreadPoolUtils();
                    return pool;
                }
            }
        }
        return pool;
    }

    // 无响应执行
    public static void execute(Runnable runnable){
        getInstance().execute(runnable);
    }

    // 有响应执行
    public static<T> Future<T> submit(Callable<T> callable){
        return getInstance().submit(callable);
    }

}

prüfen:

        Die Hauptmethode testet den Code, erstellt 20 Runnables, simuliert tatsächliche Geschäftsaufgaben und stellt sie zur Ausführung in den Thread-Pool.

    public static void main(String[] args) {
        System.out.println("测试执行20个任务");
        for (int i=0; i<20; i++){
            String aa = "执行任务：" + (i+1);
            PushThreadPoolUtils.execute( new Runnable() {
                public void run(){
                    System.out.println(aa);
                }
            });
        }
    }

Testergebnisse:

        Es ist ersichtlich, dass der Thread-Pool Thread-Aufgaben normal erstellt und ausführt und auch die Ausführungsreihenfolge der Aufgaben nicht in der richtigen Reihenfolge ist, da beim Erstellen eines Threads zum Ausführen einer Aufgabe mehrere bereite Threads um die CPU konkurrieren, sodass sie dies tun können zuerst ausgeführt werden, anstatt zuerst erstellt zu werden. Dies beweist, dass die Verwendung eines Thread-Pools die serielle Verarbeitung in eine parallele Verarbeitung umwandelt

测试执行20个任务
14:59:28.188 [main] INFO  c.r.q.u.PushThreadPoolUtils - [<init>,28] - PushThreadPoolUtils 线程池创建完成
执行任务：2
执行任务：1
执行任务：4
执行任务：3
执行任务：5
执行任务：6
执行任务：7
执行任务：8
执行任务：11
执行任务：9
执行任务：12
执行任务：13
执行任务：14
执行任务：15
执行任务：17
执行任务：18
执行任务：19
执行任务：20
执行任务：10
执行任务：16

        Die Blockierungswarteschlange des Thread-Pools, die Thread-Factory und die Ablehnungsrichtlinie nach Überlastung sind alle optional, und Sie können je nach Ihren eigenen Geschäftsbedingungen unterschiedliche Entscheidungen treffen.