java中自带的线程工厂

Java提供了以下几种线程工厂：

1. ThreadFactory 接口：这是一个基本的线程工厂接口，用于创建新的线程。通常会使用线程工厂的默认实现Executors.defaultThreadFactory()。
2. Executors.DefaultThreadFactory 类：这是ThreadFactory接口的默认实现。该工厂创建的线程都是普通优先级、非守护线程。
3. Executors.SameThreadExecutor 类：这个线程工厂创建的线程都在同一个线程中执行任务。即，所有的任务都在主线程中顺序执行，不会有多线程的并发执行。
4. Executors.DefaultManagedAwareThreadFactory 类：这是在Java 9中引入的线程工厂，用于创建ForkJoinPool线程池。它创建的线程都是普通优先级、非守护线程，而且允许自定义线程的名称。

除了这些内置的线程工厂，也可以自定义实现ThreadFactory接口来创建自己的线程工厂。例如，可以根据需要设置线程的属性，如线程名称、优先级、是否守护线程等。

下面是一个自定义的线程工厂示例：

import java.util.concurrent.ThreadFactory;

public class CustomThreadFactory implements ThreadFactory {
    private final String threadNamePrefix;                     // 线程名称前缀
    private final int threadPriority;                          // 线程优先级
    private final boolean isDaemon;                            // 是否为守护线程
    private final Thread.UncaughtExceptionHandler exceptionHandler;    // 线程异常处理器

    /**
     * 构造函数
     * @param threadNamePrefix 线程名称前缀
     * @param threadPriority 线程优先级
     * @param isDaemon 是否为守护线程
     * @param exceptionHandler 线程异常处理器
     */
    public CustomThreadFactory(String threadNamePrefix, int threadPriority, boolean isDaemon,
            Thread.UncaughtExceptionHandler exceptionHandler) {
        this.threadNamePrefix = threadNamePrefix;
        this.threadPriority = threadPriority;
        this.isDaemon = isDaemon;
        this.exceptionHandler = exceptionHandler;
    }

    @Override
    public Thread newThread(Runnable r) {
        Thread t = new Thread(r);
        t.setName(threadNamePrefix + "-" + t.getId());          // 设置线程名称
        t.setPriority(threadPriority);                          // 设置线程优先级
        t.setDaemon(isDaemon);                                  // 设置线程是否为守护线程
        t.setUncaughtExceptionHandler(exceptionHandler);        // 设置线程异常处理器
        return t;
    }
}

这是一个自定义的线程工厂类，实现了ThreadFactory接口。它具有四个可选参数：线程名称前缀、线程优先级、是否为守护线程以及线程异常处理器。

下面是一个使用CustomThreadFactory的示例：

public class CustomThreadFactoryExample {
    public static void main(String[] args) {
        // 创建自定义线程工厂实例
        ThreadFactory customThreadFactory = new CustomThreadFactory("CustomThread", Thread.MAX_PRIORITY, true,
                new Thread.UncaughtExceptionHandler() {
                    @Override
                    public void uncaughtException(Thread t, Throwable e) {
                        System.out.println("Uncaught exception in thread: " + t.getName());
                    }
                });

        // 创建一个简单的任务
        Runnable task = new Runnable() {
            @Override
            public void run() {
                System.out.println("Task is running in thread: " + Thread.currentThread().getName());
                throw new RuntimeException("Exception in thread " + Thread.currentThread().getName());
            }
        };

        // 使用自定义线程工厂创建线程并启动
        Thread thread = customThreadFactory.newThread(task);
        thread.start();
    }
}

在该示例中，创建了一个自定义线程工厂customThreadFactory，指定了线程名称前缀为"CustomThread"，线程优先级为Thread.MAX_PRIORITY（最高优先级），将线程设置为守护线程，以及指定了处理未捕获异常的异常处理器。

然后，创建一个简单的任务task，并通过customThreadFactory创建了一个新的线程thread，并启动它。

当运行示例时，输出结果将类似于以下内容：

Task is running in thread: CustomThread-1
Uncaught exception in thread: CustomThread-1

我们可以看到，创建的线程具有根据自定义线程工厂设置的线程名称、优先级、守护属性，并且当任务抛出未捕获的异常时，由线程的异常处理器进行处理。

总结：Java提供了多种线程工厂的实现，包括默认的ThreadFactory接口实现、Executors.DefaultThreadFactory、Executors.SameThreadExecutor和Executors.DefaultManagedAwareThreadFactory。此外，还可以自定义实现ThreadFactory接口，根据需要设置线程的属性。