创建线程池并使用

一、函数式接口编程,实现通用的Builder
二、线程池配置
三、yml文件配置
使用

一、函数式接口编程,实现通用的Builder

public class GenericBuilder {

    private final Supplier instantiator;

    private List> instanceModifiers = new ArrayList<>();

    public GenericBuilder(Supplier instantiator) {
        this.instantiator = instantiator;
    }

    public static  GenericBuilder of(Supplier instantiator) {
        return new GenericBuilder(instantiator);
    }

    public  GenericBuilder with(BiConsumer consumer, U value) {
        Consumer c = instance -> consumer.accept(instance, value);
        instanceModifiers.add(c);
        return this;
    }

    public T build() {
        T value = instantiator.get();
        instanceModifiers.forEach(modifier -> modifier.accept(value));
        instanceModifiers.clear();
        return value;
    }
}

二、线程池配置

package com.erp.payroll.core.config;

import com.erp.payroll.common.builder.GenericBuilder;
import com.google.common.util.concurrent.ThreadFactoryBuilder;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.EnableAsync;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.linkedBlockingDeque;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import org.springframework.beans.factory.annotation.Value;


@Configuration
@EnableAsync
public class TheadPoolConfig {

    private final Logger log = LoggerFactory.getLogger(getClass());


    @Value("${thread.pool.core-size:50}")
    private int corePoolSize;

    @Value("${thread.pool.maximum-size:200}")
    private int maxPoolSize;

    @Value("${thread.pool.blockqueue-size:1000}")
    private int queue;

    @Value("${thread.pool.keepalive-time:60}")
    private int keepAliveTime;

    @Bean(name = "commonExecutor")
    public ExecutorService executorService() {

        ThreadFactoryBuilder factoryBuilder = GenericBuilder.of(ThreadFactoryBuilder::new)
                .with(ThreadFactoryBuilder::setDaemon, true)
                .with(ThreadFactoryBuilder::setNameFormat, "payroll-common-executor-%d")
                .with(ThreadFactoryBuilder::setUncaughtExceptionHandler,
                        (t, e) -> log.error("线程" + t.getName() + "运行异常", e))
                .build();

        ThreadPoolExecutor executor =
                new ThreadPoolExecutor(corePoolSize, maxPoolSize, keepAliveTime, TimeUnit.MILLISECONDS, new linkedBlockingDeque<>(queue));
        executor.setThreadFactory(factoryBuilder.build());
        return executor;
    }
}

三、yml文件配置

# 线程池设置
thread:
  pool:
    core-size: 50
    maximum-size: 200
    blockqueue-size: 1000
    keepalive-time: 60

使用

@Resource
    private ExecutorService executorService;

public void test(){
        System.out.println("begin ...");

        executorService.execute(()->print());
    }

    private void print(){
        System.out.println("Hello world !");
    }


// 或者使用submit方法
executorService.submit(()->print());

链接: 线程池使用.
链接: Java线程池如何合理配置核心线程数.

创建线程池并使用

Java相关栏目本月热门文章