【多线程】（五）工厂模式和线程池

---

一、工厂模式

在Java中，工厂模式是一种创建对象的设计模式，它通过提供一个共同的接口来实例化对象，而不暴露具体实现的细节。工厂模式可以帮助我们解耦对象的创建和使用，提供了一种灵活的方式来创建对象。

在工厂模式中，通常有一个抽象的工厂接口，该接口定义了创建对象的方法。然后，有一个或多个具体的工厂类实现这个接口，每个工厂类负责创建一种具体类型的对象。

下面是一个简单的示例，演示了在Java中如何使用工厂模式：

首先，我们定义一个抽象的产品接口：

public interface Product {
    void doSomething();
}

然后，我们创建两个具体的产品类，实现产品接口：

public class ConcreteProduct1 implements Product {
    @Override
    public void doSomething() {
        System.out.println("ConcreteProduct1 do something");
    }
}

public class ConcreteProduct2 implements Product {
    @Override
    public void doSomething() {
        System.out.println("ConcreteProduct2 do something");
    }
}

接下来，我们定义一个抽象的工厂接口：

public interface Factory {
    Product createProduct();
}

然后，我们创建两个具体的工厂类，实现工厂接口：

public class ConcreteFactory1 implements Factory {
    @Override
    public Product createProduct() {
        return new ConcreteProduct1();
    }
}

public class ConcreteFactory2 implements Factory {
    @Override
    public Product createProduct() {
        return new ConcreteProduct2();
    }
}

最后，我们可以使用工厂来创建具体的产品对象，而不需要直接实例化具体的产品类：

public class Main {
    public static void main(String[] args) {
        Factory factory1 = new ConcreteFactory1();
        Product product1 = factory1.createProduct();
        product1.doSomething();

        Factory factory2 = new ConcreteFactory2();
        Product product2 = factory2.createProduct();
        product2.doSomething();
    }
}

运行上述示例，将会输出以下内容：

ConcreteProduct1 do something
ConcreteProduct2 do something

这样，我们通过工厂模式，实现了创建产品对象的过程和具体产品的实现相分离，客户端只需要通过工厂接口创建产品对象，而不需要关心具体的产品类。这种设计模式使得系统更具有灵活性和可扩展性。

二、线程池

2.1 什么是线程池

线程池是Java中的一个重要概念，它是一种管理和复用线程的机制。线程池维护着一个线程队列，其中包含着多个准备好的线程。当有任务需要执行时，线程池中的线程可以被分配来执行任务，执行完成后又可以返回线程池以供下一次使用。

引入线程池的主要目的是为了提高系统的性能和资源利用率。以下是引入线程池的一些好处：

1. 减少线程创建和销毁的开销
2. 控制并发线程的数量
3. 提高响应速度和吞吐量
4. 提供线程管理和监控
5. 任务队列和调度策略

2.2 Executor 工厂类创建线程池

Java中的java.util.concurrent.Executors类提供了一个工厂方法来创建不同类型的线程池。这个工厂类提供了一些方便的方法来创建常见类型的线程池。以下是一些常用的线程池创建方法：

1. FixedThreadPool（固定大小线程池）：创建一个固定大小的线程池，一旦线程池达到最大线程数量，其他任务会等待。可以使用 Executors.newFixedThreadPool(int nThreads) 方法创建。

ExecutorService executor = Executors.newFixedThreadPool(5);
executor.submit(new MyTask()); // 提交任务给线程池执行
executor.shutdown(); // 关闭线程池

2. CachedThreadPool（缓存线程池）：根据需要创建新线程，但如果有空闲线程则复用。如果线程空闲时间超过指定的时间（默认为60秒），则会被终止并从线程池中移除。可以使用 Executors.newCachedThreadPool() 方法创建。

ExecutorService executor = Executors.newCachedThreadPool();
executor.submit(new MyTask()); // 提交任务给线程池执行
executor.shutdown(); // 关闭线程池

3. SingleThreadExecutor（单线程线程池）：只创建一个线程的线程池，保证所有任务按顺序执行。可以使用 Executors.newSingleThreadExecutor() 方法创建。

ExecutorService executor = Executors.newSingleThreadExecutor();
executor.submit(new MyTask()); // 提交任务给线程池执行
executor.shutdown(); // 关闭线程池

4. newScheduledThreadPool(定时线程池)：创建一个固定大小的线程池，可用于执行定时任务和周期性任务。

ExecutorService executor = Executors.newScheduledThreadPool(3);
executor.submit(new MyTask()); // 提交任务给线程池执行
executor.shutdown(); // 关闭线程池

这些线程池的使用方法类似，通过 submit() 方法提交任务给线程池执行，shutdown() 方法用于关闭线程池。可以根据实际需求选择适合的线程池类型，并根据需要调整线程池的大小和配置。

2.3 ThreadPoolExecutor类创建线程池

Executors 本质上是对 ThreadPoolExecutor 类的封装，ThreadPoolExecutor类是ExecutorService接口的实现，它提供了更灵活的线程池创建和配置选项。通过使用ThreadPoolExecutor类，可以自定义线程池的行为、线程数量、任务队列、拒绝策略等。

ThreadPoolExecutor 提供了更多的可选参数，可以进一步细化线程池行为的设定，以下是ThreadPoolExecutor类的构造函数及其说明：

构造函数	说明
ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue)	创建一个线程池，具有指定的核心线程数、最大线程数和任务队列，使用默认的拒绝策略。
ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, RejectedExecutionHandler handler)	创建一个线程池，具有指定的核心线程数、最大线程数、任务队列和拒绝策略。
ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, ThreadFactory threadFactory)	创建一个线程池，具有指定的核心线程数、最大线程数、任务队列和线程工厂。线程工厂用于创建线程的实例。
ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, ThreadFactory threadFactory, RejectedExecutionHandler handler)	创建一个线程池，具有指定的核心线程数、最大线程数、任务队列、线程工厂和拒绝策略。线程工厂用于创建线程的实例，拒绝策略用于处理无法执行的任务。

注意：上述构造函数中的参数含义如下：

• corePoolSize：核心线程数，表示线程池中保持活动状态的线程数量，即使它们处于空闲状态。
• maximumPoolSize：最大线程数，表示线程池中允许存在的最大线程数量，包括核心线程和非核心线程。
• keepAliveTime：非核心线程的闲置超时时间，当线程池中的线程数量超过核心线程数时，多余的空闲线程会在指定的时间内被回收。
• unit：闲置超时时间的单位，例如，TimeUnit.SECONDS表示以秒为单位。
• workQueue：任务队列，用于存储待执行的任务。
• threadFactory：线程工厂，用于创建线程的实例。
• handler：拒绝策略，表示当线程池和任务队列都已满时，新提交的任务如何被拒绝执行。
  • AbortPolicy()：超过负荷, 直接抛出异常。
  • CallerRunsPolicy()：调用者负责处理。
  • DiscardOldestPolicy()：丢弃队列中最老的任务。
  • DiscardPolicy()：丢弃新来的任务。

下面是使用ThreadPoolExecutor类创建线程池的示例：

int corePoolSize = 5; // 核心线程数
int maximumPoolSize = 10; // 最大线程数
long keepAliveTime = 60L; // 非核心线程的闲置超时时间
TimeUnit unit = TimeUnit.SECONDS; // 闲置超时时间的单位
BlockingQueue<Runnable> workQueue = new LinkedBlockingQueue<>(); // 任务队列
RejectedExecutionHandler handler = new ThreadPoolExecutor.AbortPolicy(); // 拒绝策略

ExecutorService executor = new ThreadPoolExecutor(
    corePoolSize,
    maximumPoolSize,
    keepAliveTime,
    unit,
    workQueue,
    handler
);

三、线程池的实现

创建一个简单的线程池：

// 自定义线程池
class MyThreadPool{
    // 任务队列
    private BlockingQueue<Runnable> queue = new LinkedBlockingQueue<>();

    // n 表示线程池数量
    public MyThreadPool(int n){
        // 创建n个线程
        for (int i = 0; i < n; i++) {
            Thread t = new Thread(() -> {
               while (true){
                   try {
                       Runnable runnable = queue.take();
                       runnable.run();
                   } catch (InterruptedException e) {
                       e.printStackTrace();
                   }
               }
            });
            t.start();
        }
    }

    // 注册任务给线程池
    public void submit(Runnable runnable){
        try {
            queue.put(runnable);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

• 以上代码展示了一个简单的自定义线程池实现。该自定义线程池类名为MyThreadPool，通过构造函数传入线程池数量n，并使用一个BlockingQueue作为任务队列来存储待执行的任务。
• 在构造函数中，创建了n个线程，并在每个线程中使用一个循环来不断从任务队列中取出任务并执行。
• submit()方法用于向线程池提交任务，将任务放入任务队列中。