@Target({ElementType.TYPE})@Retention(RetentionPolicy.RUNTIME)@Documented@Inherited<1.>@SpringBootConfiguration<2.>@ComponentScan<3.>@EnableAutoConfigurationpublic @interface SpringBootApplication { } @Target({ElementType.TYPE})@Retention(RetentionPolicy.RUNTIME)@Documented@Configuration //实际上它也是一个配置类public @interface SpringBootConfiguration {}

@Target({ElementType.TYPE})@Retention(RetentionPolicy.RUNTIME)@Documented@Inherited@AutoConfigurationPackage //作用：将main包下的所欲组件注册到容器中@Import({AutoConfigurationImportSelector.class}) //加载自动装配类 xxxAutoconfigurationpublic @interface EnableAutoConfiguration {    String ENABLED_OVERRIDE_PROPERTY = "spring.boot.enableautoconfiguration";     Class<?>[] exclude() default {};     String[] excludeName() default {};}

public class AutoConfigurationImportSelector implements DeferredImportSelector, BeanClassLoaderAware, ResourceLoaderAware, BeanFactoryAware, EnvironmentAware, Ordered { } public interface DeferredImportSelector extends ImportSelector { } public interface ImportSelector {    String[] selectImports(AnnotationMetadata var1);}

private static final String[] NO_IMPORTS = new String[0];
public String[] selectImports(AnnotationMetadata annotationMetadata) {        // <1>.判断自动装配开关是否打开        if (!this.isEnabled(annotationMetadata)) {            return NO_IMPORTS;        } else {          //<2>.获取所有需要装配的bean            AutoConfigurationMetadata autoConfigurationMetadata = AutoConfigurationMetadataLoader.loadMetadata(this.beanClassLoader);            AutoConfigurationImportSelector.AutoConfigurationEntry autoConfigurationEntry = this.getAutoConfigurationEntry(autoConfigurationMetadata, annotationMetadata);            return StringUtils.toStringArray(autoConfigurationEntry.getConfigurations());        }    }

private static final AutoConfigurationEntry EMPTY_ENTRY = new AutoConfigurationEntry(); AutoConfigurationEntry getAutoConfigurationEntry(AutoConfigurationMetadata autoConfigurationMetadata, AnnotationMetadata annotationMetadata) {        //<1>.第一步        if (!this.isEnabled(annotationMetadata)) {            return EMPTY_ENTRY;        } else {            //<2>.第二步            AnnotationAttributes attributes = this.getAttributes(annotationMetadata);            //<3>.第三步            List<String> configurations = this.getCandidateConfigurations(annotationMetadata, attributes);            //<4>.第四步            configurations = this.removeDuplicates(configurations);            Set<String> exclusions = this.getExclusions(annotationMetadata, attributes);            this.checkExcludedClasses(configurations, exclusions);            configurations.removeAll(exclusions);            configurations = this.filter(configurations, autoConfigurationMetadata);            this.fireAutoConfigurationImportEvents(configurations, exclusions);            return new AutoConfigurationImportSelector.AutoConfigurationEntry(configurations, exclusions);        }    }

@ConditionalOnBean：当容器里有指定 Bean 的条件下@ConditionalOnMissingBean：当容器里没有指定 Bean 的情况下@ConditionalOnSingleCandidate：当指定 Bean 在容器中只有一个，或者虽然有多个但是指定首选 Bean@ConditionalOnClass：当类路径下有指定类的条件下@ConditionalOnMissingClass：当类路径下没有指定类的条件下@ConditionalOnProperty：指定的属性是否有指定的值@ConditionalOnResource：类路径是否有指定的值@ConditionalOnExpression：基于 SpEL 表达式作为判断条件@ConditionalOnJava：基于 Java 版本作为判断条件@ConditionalOnJndi：在 JNDI 存在的条件下差在指定的位置@ConditionalOnNotWebApplication：当前项目不是 Web 项目的条件下@ConditionalOnWebApplication：当前项目是 Web 项 目的条件下

package com.yanhua.fast_build_starter.configuration; import org.slf4j.Logger;import org.slf4j.LoggerFactory;import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;import org.springframework.context.annotation.Bean;import org.springframework.context.annotation.Configuration; import java.util.concurrent.*;import java.util.concurrent.atomic.AtomicInteger; /** * 自动装配线程池 * * @ConditionalOnClass 检测ThreadPoolExecutor存在，才会SpringBoot装配 */@Configurationpublic class ThreadPoolAutoConfiguration {    @Bean    @ConditionalOnClass(ThreadPoolExecutor.class)    public ThreadPoolExecutor FailFastThreadPool() {        int corePoolSize = Runtime.getRuntime().availableProcessors();        int maximumPoolSize = Runtime.getRuntime().availableProcessors() * 2 + 1;        long keepAliveTime = 10;        TimeUnit unit = TimeUnit.SECONDS;        BlockingQueue<Runnable> workQueue = new ArrayBlockingQueue<>(100);        ThreadFactory threadFactory = new FastBuildThreadFactory("FastBuild");        RejectedExecutionHandler handler = new FastBuildAbortPolicy("FastBuild");        return new ThreadPoolExecutor(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, threadFactory, handler);    }} /** * 1、自定义的线程工厂 * 2、一定要起线程别名 * 3、通过jstack或者authas查看线程名称 */class FastBuildThreadFactory implements ThreadFactory {    private final AtomicInteger threadNum = new AtomicInteger(1);    private String threadName;     public FastBuildThreadFactory(String threadName) {        this.threadName = threadName;    }     @Override    public Thread newThread(Runnable r) {        Thread t = new Thread(r, threadName + "_" + threadNum.getAndIncrement());        if (t.isDaemon()) {            t.setDaemon(true);        }        if (t.getPriority() != Thread.NORM_PRIORITY) {            t.setPriority(Thread.NORM_PRIORITY);        }        return t;    }} /** * 1、自定义拒绝策略 * 2、队列满后进行阻塞 * 3、默认：异常，抛弃，最老抛弃，调用线程运行 */class FastBuildAbortPolicy extends ThreadPoolExecutor.AbortPolicy {    private static final Logger LOG = LoggerFactory.getLogger(FastBuildAbortPolicy.class);     private final String threadName;     public FastBuildAbortPolicy(String threadName) {        this.threadName = threadName;    }     @Override    public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {        String msg = String.format("Provider端线程池满!" +                        " Thread Name: %s, Pool Size: %d (active: %d, core: %d, max: %d, largest: %d), Task: %d (completed: %d)," +                        " Executor status:(isShutdown:%s, isTerminated:%s, isTerminating:%s)",                threadName, e.getPoolSize(), e.getActiveCount(), e.getCorePoolSize(), e.getMaximumPoolSize(), e.getLargestPoolSize(),                e.getTaskCount(), e.getCompletedTaskCount(), e.isShutdown(), e.isTerminated(), e.isTerminating());        LOG.warn(msg);        if (!e.isShutdown()) {            try {                LOG.info("Start get queue");                e.getQueue().put(r);                LOG.info("End get queue");            } catch (InterruptedException ee) {                LOG.error(ee.toString(), ee);                Thread.currentThread().interrupt();            }        }    }}

org.springframework.boot.autoconfigure.EnableAutoConfiguration=\com.yanhua.fast_build_starter.configuration.ThreadPoolAutoConfiguration

@Test    public void FailFastThreadPool() {        ThreadPoolAutoConfiguration configuration = new ThreadPoolAutoConfiguration();        ThreadPoolExecutor poolExecutor = configuration.FailFastThreadPool();        for (int i = 0; i < 150; i++) {            poolExecutor.submit(() -> {                try {                    System.out.println("ThreadName:" + Thread.currentThread().getName() + " Start");                    Thread.sleep(10000);                } catch (InterruptedException e) {                    e.printStackTrace();                }            });        }    }

mvn clean install

<dependency>    <groupId>com.yanhua</groupId>    <artifactId>fast_build_starter</artifactId>    <version>0.0.1-SNAPSHOT</version></dependency>