线程工厂构建器与线程池构建器(上)

import org.opengoofy.index12306.framework.starter.designpattern.builder.Builder;

import java.util.concurrent.Executors;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.atomic.AtomicLong;

ThreadFactoryBuilder 是一个线程工厂构建器，用于创建 ThreadFactory 实例，该实例可以用于创建线程对象。在多线程编程中，线程工厂用于封装线程的创建过程，可以自定义线程的属性和行为。

这个类提供了若干个方法，用于设置线程工厂的属性，如：线程工厂的前缀、是否为守护线程、线程优先级、未捕获异常处理器等。其中的 build() 方法用于构建出一个新的 ThreadFactory 实例，并返回。

通过使用 ThreadFactoryBuilder 构建出的 ThreadFactory 实例，可以根据需要定制线程的属性和行为。例如，可以给线程命名、设置线程是否为守护线程、设置线程优先级、设置未捕获异常处理器等。这样做有助于更好地管理和监控线程的执行情况。

public final class ThreadFactoryBuilder implements Builder<ThreadFactory> {

    private static final long serialVersionUID = 1L;

    private ThreadFactory backingThreadFactory;

    private String namePrefix;

    private Boolean daemon;

    private Integer priority;

    private Thread.UncaughtExceptionHandler uncaughtExceptionHandler;

    public ThreadFactoryBuilder threadFactory(ThreadFactory backingThreadFactory) {
        this.backingThreadFactory = backingThreadFactory;
        return this;
    }

    public ThreadFactoryBuilder prefix(String namePrefix) {
        this.namePrefix = namePrefix;
        return this;
    }

    public ThreadFactoryBuilder daemon(boolean daemon) {
        this.daemon = daemon;
        return this;
    }

    public ThreadFactoryBuilder priority(int priority) {
        if (priority < Thread.MIN_PRIORITY) {
            throw new IllegalArgumentException(String.format("Thread priority ({}) must be >= {}", priority, Thread.MIN_PRIORITY));
        }
        if (priority > Thread.MAX_PRIORITY) {
            throw new IllegalArgumentException(String.format("Thread priority ({}) must be <= {}", priority, Thread.MAX_PRIORITY));
        }
        this.priority = priority;
        return this;
    }

    public void uncaughtExceptionHandler(Thread.UncaughtExceptionHandler uncaughtExceptionHandler) {
        this.uncaughtExceptionHandler = uncaughtExceptionHandler;
    }

    public static ThreadFactoryBuilder builder() {
        return new ThreadFactoryBuilder();
    }

    @Override
    public ThreadFactory build() {
        return build(this);
    }


在build()方法中，会根据构建器中设置的属性，创建一个新的线程工厂。这个新的线程工厂会基于传入的 backingThreadFactory（如果存在）或者默认的线程工厂来创建线程。然后，会根据构建器中设置的属性，对线程进行定制，如设置线程名称、是否为守护线程、线程优先级、未捕获异常处理器等。最后，返回定制后的线程。

    private static ThreadFactory build(ThreadFactoryBuilder builder) {
        final ThreadFactory backingThreadFactory = (null != builder.backingThreadFactory)
                ? builder.backingThreadFactory
                : Executors.defaultThreadFactory();
        final String namePrefix = builder.namePrefix;
        final Boolean daemon = builder.daemon;
        final Integer priority = builder.priority;
        final Thread.UncaughtExceptionHandler handler = builder.uncaughtExceptionHandler;
        final AtomicLong count = (null == namePrefix) ? null : new AtomicLong();
        return r -> {
            final Thread thread = backingThreadFactory.newThread(r);
            if (null != namePrefix) {
                thread.setName(namePrefix + "_" + count.getAndIncrement());
            }
            if (null != daemon) {
                thread.setDaemon(daemon);
            }
            if (null != priority) {
                thread.setPriority(priority);
            }
            if (null != handler) {
                thread.setUncaughtExceptionHandler(handler);
            }
            return thread;
        };
    }
}