线程池与工厂模式

目录

♫什么是线程池

♫线程池的优点

♫工厂模式

♫工厂模式的意义

♫线程池的使用

♫线程池常见的创建方法

♫ThreadPoolExecutor

 ♫实现一个线程池

---

♫什么是线程池

线程池是一种管理和复用线程的技术，它在应用程序启动时预先创建一组线程，并将它们存储在一个池中等待任务。当应用程序需要执行一个任务时，它从线程池中获取一个线程，将任务交给该线程执行，执行完成后该线程就会返回线程池等待下一个任务。

♫线程池的优点

线程池的优点是可以避免频繁地创建和销毁线程带来的性能开销，通过线程池获取线程和归还线程通过代码就能实现，相比于直接通过操作系统内核来获取和销毁线程来说开销要小很多。（就好比买饭时，可以自己去食堂买，也可以叫舍友帮你买。自己买目标明确，行为可控；而叫舍友买，舍友可能先去干其它事情再去买，整体行为是不可控的）此外，线程池还可以控制应用程序中的并发线程数，避免因线程过多而造成系统资源的浪费和线程调度的开销。

♫工厂模式

Java标准库提供了现成的线程池，我们可以直接使用：

//创建一个线程数目为10的线程池
ExecutorService pool = Executors.newFixedThreadPool(10);

获取线程池的操作不同于我们常用的通过 new 或取对象的实例，它是直接通过 Executors 类的静态方法构造出一个对象来（相当于把new操作隐藏在静态方法里）。像这样的方法就叫作工厂方法，提供该方法的类就叫作工厂类，此处代码就使用了工厂模式这一设计模式。

♫工厂模式的意义

工厂模式就是使用普通方法来代替构造方法创建对象，那直接通过构造方法来创建对象不好吗，为什么还要有工厂模式？

这是因为构造方法是通过重载来提供多个构造方法的，但重载中函数名必须相同，函数参数的类型或数目必须不同，这就导致我们不能提供两个参数和类型都相同的构造方法，而通过工厂模式就可以提供两个参数类型和个数都相同的构造方法：

//抽象产品类
interface Product {
    void operation();
}

//具体产品类A
class ProductA implements Product {
    public void operation() {
        System.out.println("ProductA operation.");
    }
}

//具体产品类B
class ProductB implements Product {
    public void operation() {
        System.out.println("ProductB operation.");
    }
}

//工厂类
class Factory {
    public static Product createProduct(String productType) {
        if(productType.equals("A")) {
            return new ProductA();
        } else if(productType.equals("B")) {
            return new ProductB();
        } else {
            return null;
        }
    }
}

//客户端代码
public class Test {
    public static void main(String[] args) {
        Product product = Factory.createProduct("A");
        product.operation();
        
        product = Factory.createProduct("B");
        product.operation();
    }
}

运行结果：

前面我们已经提供标准库创建了一个线程包含10个线程的线程池，接下来我们就来使用这个线程池。

♫线程池的使用

通过 submit 方法可以给线程池提供若干任务，这些任务被分配给线程池里的线程去执行：

public class Test {
    public static void main(String[] args) {
        //创建一个线程数目为10的线程池
        ExecutorService pool = Executors.newFixedThreadPool(10);
        for (int i = 0; i < 100; i++) {
            int n = i;
            pool.submit(new Runnable() {
                @Override
                public void run() {
                    System.out.println(n);
                }
            });
        }
    }
}

运行结果：

注：

①.线程池里的线程是非守护线程，会阻止进程结束。可以看到，上面程序中主线程执行完，但整个进程仍未结束

②.其他线程里使用主线程里的变量涉及到变量捕获，而变量捕获只能捕获 final 修饰的变量或隐式 final 的变量，故 run() 里不能直接使用变量 i 

③.任务不是平均分配给线程池里的线程，而是哪个线程执行完就接着执行

♫线程池常见的创建方法

 Executors类有以下几种常见的静态方法可以创建线程池：

♪.newFixedThreadPool：执行要创建多少个线程
♪.newSingleThreadExecutor：线程池里只有一个线程
♪.newCachedThreadPool：线程数量是动态变化的，任务多了，就多搞几个线程，任务少了，就少搞几个线程
♪.newScheduledThreadPool：类似于定时器，也是让任务延迟执行，只不过不是用扫描线程执行，而是由线程池里的线程来执行

上述这些线程池本质上都是通过包装 ThreadPoolExecutor 来实现的，下面我们就来看看 ThreadPoolExecutor。

♫ThreadPoolExecutor

通过帮助手册查看 ThreadPoolExecutor 类的构造方法：

 ♪.corePoolSize：线程池的核心线程数，即最小保持活动状态的线程数。

 ♪.maximumPoolSize：线程池的最大线程数，即最多能创建多少个线程。

 ♪.keepAliveTime：空闲线程的存活时间，即如果线程池中的线程数量大于 corePoolSize，那么多余的线程在空闲一定时间后将被销毁，直到线程池中的线程数重新达到 corePoolSize 为止。

 ♪.unit：keepAliveTime 的时间单位。

 ♪.workQueue：阻塞队列，用于保存等待执行的任务。线程池中的线程会从队列中取出任务并执行。

♪.threadFactory：线程工厂，用于创建新的线程。

♪.handler：拒绝策略，用于处理任务添加到线程池失败的情况。常见的拒绝策略有：

♩.AbortPolicy：如果队列满了，直接抛出异常

♩.CallerRunsPolicy：如果队列满了，让提交新任务的线程自己去执行该任务。

♩.DiscardOldestPolicy：如果队列满了，尝试将等待时间最长的任务从队列中取出，然后将该任务丢弃，再将新提交的任务加入队列中

♩.DiscardPolicy：如果队列满了，直接丢弃新任务，不做任何处理

了解了Java标准库里的线程池，接下来就来实现一个指定固定线程数的线程池。

 ♫实现一个线程池

通过submit添加任务，通过阻塞队列存储任务，在构造方法里创建指定数目的线程，每个线程都循环获取队列中的任务并执行该任务，直到队列为空：

import java.util.concurrent.LinkedBlockingQueue;

public class MyThreadPool {
    //阻塞队列存放任务
    private LinkedBlockingQueue<Runnable> queue = new LinkedBlockingQueue<>();

    //注册任务
    public void submit(Runnable runnable) {
        try {
            queue.put(runnable);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    
    //n表示线程数量
    public MyThreadPool(int 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();
        }
    }
}