深入理解高并发编程 - 分析创建线程池究竟有哪些方式

小咪咪 2023-10-14 19:56 32阅读 0赞

## 1、使用Executors工厂方法： ##

使用Executors工厂方法创建线程池是一种简单快捷的方式，适用于一些常见的线程池需求。以下是几个示例，演示如何使用Executors工厂方法创建不同类型的线程池：

### 固定大小线程池 (newFixedThreadPool)： ###

这种类型的线程池会一直保持固定数量的线程在池中，不会自动回收线程。适用于需要限制同时执行的任务数量的场景。

import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    
    public class FixedThreadPoolExample {
        public static void main(String[] args) {
            int numThreads = 5;
            ExecutorService executor = Executors.newFixedThreadPool(numThreads);
    
            // 提交任务到线程池
            for (int i = 0; i < 10; i++) {
                executor.submit(new MyRunnable(i));
            }
    
            executor.shutdown(); // 关闭线程池
        }
    }

### 缓存线程池 (newCachedThreadPool)： ###

缓存线程池会根据需要创建新的线程，如果线程池中的线程空闲时间超过指定的时间，则会被回收。适用于任务数量不确定，且需要自动调整线程数的场景。

import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    
    public class CachedThreadPoolExample {
        public static void main(String[] args) {
            ExecutorService executor = Executors.newCachedThreadPool();
    
            // 提交任务到线程池
            for (int i = 0; i < 10; i++) {
                executor.submit(new MyRunnable(i));
            }
    
            executor.shutdown(); // 关闭线程池
        }
    }

### 单线程线程池 (newSingleThreadExecutor)： ###

单线程线程池只有一个工作线程，适用于需要按顺序执行任务的场景。

import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    
    public class SingleThreadExecutorExample {
        public static void main(String[] args) {
            ExecutorService executor = Executors.newSingleThreadExecutor();
    
            // 提交任务到线程池
            for (int i = 0; i < 10; i++) {
                executor.submit(new MyRunnable(i));
            }
    
            executor.shutdown(); // 关闭线程池
        }
    }

### 定时任务线程池 (newScheduledThreadPool)： ###

定时任务线程池用于执行定时任务和周期性任务。

在这些示例中，MyRunnable是一个实现了Runnable接口的自定义任务类。创建线程池后，使用submit方法将任务提交给线程池进行执行，并最终调用shutdown方法关闭线程池。

这些Executors工厂方法提供了一些常见的线程池类型，但在某些情况下，可能需要更精细的线程池配置，这时可以考虑手动创建ThreadPoolExecutor。

## 2、手动创建ThreadPoolExecutor： ##

手动创建 ThreadPoolExecutor 允许对线程池的各种参数进行更精细的配置，以满足特定的需求。以下是一个示例，演示如何手动创建 ThreadPoolExecutor：

import java.util.concurrent.BlockingQueue;
    import java.util.concurrent.LinkedBlockingQueue;
    import java.util.concurrent.ThreadPoolExecutor;
    import java.util.concurrent.TimeUnit;
    
    public class ManualThreadPoolExecutorExample {
        public static void main(String[] args) {
            int corePoolSize = 5;
            int maxPoolSize = 10;
            long keepAliveTime = 60; // 60秒
            TimeUnit timeUnit = TimeUnit.SECONDS;
            BlockingQueue<Runnable> workQueue = new LinkedBlockingQueue<>();
            
            ThreadPoolExecutor executor = new ThreadPoolExecutor(
                corePoolSize, maxPoolSize, keepAliveTime, timeUnit, workQueue
            );
            
            // 提交任务到线程池
            for (int i = 0; i < 10; i++) {
                executor.submit(new MyRunnable(i));
            }
            
            executor.shutdown(); // 关闭线程池
        }
    }
    
    class MyRunnable implements Runnable {
        private int id;
        
        public MyRunnable(int id) {
            this.id = id;
        }
        
        @Override
        public void run() {
            System.out.println("Task " + id + " is running on thread " + Thread.currentThread().getName());
        }
    }

在这个示例中，手动创建了一个 ThreadPoolExecutor，并配置了核心线程数、最大线程数、线程空闲时间等参数。然后，使用 submit 方法将任务提交给线程池进行执行，并最终调用 shutdown 方法关闭线程池。

注意，BlockingQueue 参数用于指定任务队列，用来存储等待执行的任务。在这里，使用了 LinkedBlockingQueue，也可以选择其他的实现，如 ArrayBlockingQueue、PriorityBlockingQueue 等，以适应不同的需求。

手动创建 ThreadPoolExecutor 允许更精细地控制线程池的行为，但也需要更多的配置和管理。在选择线程池类型和参数时，应根据应用的特性和需求进行调整。

## 3、使用ForkJoinPool： ##

ForkJoinPool 是 Java 提供的用于支持分治任务的线程池实现。它特别适用于能够将任务拆分成更小的子任务，并且这些子任务可以并行执行的情况。以下是一个使用 ForkJoinPool 创建线程池的示例：

import java.util.concurrent.ForkJoinPool;
    import java.util.concurrent.RecursiveAction;
    
    public class ForkJoinPoolExample {
        public static void main(String[] args) {
            ForkJoinPool forkJoinPool = new ForkJoinPool();
            
            MyRecursiveAction task = new MyRecursiveAction(0, 10);
            forkJoinPool.invoke(task);
            
            forkJoinPool.shutdown();
        }
    }
    
    class MyRecursiveAction extends RecursiveAction {
        private static final int THRESHOLD = 2; // 阈值，小于该值就不再分解任务
        private int start;
        private int end;
        
        public MyRecursiveAction(int start, int end) {
            this.start = start;
            this.end = end;
        }
        
        @Override
        protected void compute() {
            if (end - start <= THRESHOLD) {
                // 执行任务逻辑
                for (int i = start; i <= end; i++) {
                    System.out.println("Task is running on thread " + Thread.currentThread().getName() + ": " + i);
                }
            } else {
                // 分解任务
                int mid = (start + end) / 2;
                MyRecursiveAction left = new MyRecursiveAction(start, mid);
                MyRecursiveAction right = new MyRecursiveAction(mid + 1, end);
                
                invokeAll(left, right);
            }
        }
    }

在这个示例中，首先创建了一个 ForkJoinPool 实例，然后定义了一个继承自 RecursiveAction 的 MyRecursiveAction 类，用于表示要执行的分治任务。在 compute 方法中，首先检查任务是否足够小，如果是，则执行任务逻辑；否则，将任务分解为两个子任务并使用 invokeAll 方法并行执行。

ForkJoinPool 会根据任务的大小和可用线程数来动态地调度任务的执行，以获得最佳的并行性能。在实际使用中，可以根据任务的特性和复杂度调整阈值，以及分解和执行子任务的逻辑。

注意，ForkJoinPool 适用于能够利用分治并行计算的场景，如递归问题的解决和并行计算任务。

## 4、使用 ScheduledThreadPoolExecutor 类 ##

ScheduledThreadPoolExecutor 是 ThreadPoolExecutor 的子类，专门用于创建带有定时任务功能的线程池。它可以执行定时任务和周期性任务。以下是一个使用 ScheduledThreadPoolExecutor 创建线程池的示例：

import java.util.concurrent.Executors;
    import java.util.concurrent.ScheduledExecutorService;
    import java.util.concurrent.TimeUnit;
    
    public class ScheduledThreadPoolExecutorExample {
        public static void main(String[] args) {
            int numThreads = 3;
            ScheduledExecutorService executor = Executors.newScheduledThreadPool(numThreads);
            
            // 延迟1秒后执行任务
            executor.schedule(new MyRunnable(1), 1, TimeUnit.SECONDS);
            
            // 延迟2秒后，每3秒执行一次任务
            executor.scheduleAtFixedRate(new MyRunnable(2), 2, 3, TimeUnit.SECONDS);
            
            // 关闭线程池
            executor.shutdown();
        }
    }
    
    class MyRunnable implements Runnable {
        private int id;
        
        public MyRunnable(int id) {
            this.id = id;
        }
        
        @Override
        public void run() {
            System.out.println("Task " + id + " is running on thread " + Thread.currentThread().getName());
        }
    }

在这个示例中，使用 Executors.newScheduledThreadPool() 方法创建了一个 ScheduledExecutorService，然后使用 schedule 方法在指定的延迟时间后执行一次任务，使用 scheduleAtFixedRate 方法在指定的延迟时间后开始执行任务，并且每隔一段时间重复执行。

ScheduledThreadPoolExecutor 可以满足定时任务和周期性任务的需求，它能够自动调度任务的执行。当任务执行时间超过任务间隔时间时，ScheduledThreadPoolExecutor 会等待当前任务完成后再启动下一个任务。这种特性对于需要保证任务执行间隔的场景非常有用。

## 5、使用第三方库（如ThreadPoolExecutor的封装库）： ##

许多第三方库都提供了对 ThreadPoolExecutor 的封装，以便更方便地创建和管理线程池。其中一个常用的库是 Apache Commons Lang 中的 ThreadPoolExecutor，它提供了一些额外的功能和配置选项。以下是一个使用 Apache Commons Lang 的 ThreadPoolExecutor 封装库的示例：

首先，确保已经将 Apache Commons Lang 库添加到项目中。然后，你可以使用 org.apache.commons.lang3.concurrent.BasicThreadFactory 来创建线程池。下面是示例代码：

import org.apache.commons.lang3.concurrent.BasicThreadFactory;
    
    import java.util.concurrent.ScheduledExecutorService;
    import java.util.concurrent.ScheduledThreadPoolExecutor;
    import java.util.concurrent.TimeUnit;
    
    public class ThirdPartyThreadPoolExample {
        public static void main(String[] args) {
            int numThreads = 3;
            
            BasicThreadFactory factory = new BasicThreadFactory.Builder()
                    .namingPattern("my-pool-%d")
                    .daemon(true)
                    .build();
            
            ScheduledExecutorService executor = new ScheduledThreadPoolExecutor(
                    numThreads, factory);
            
            // 延迟1秒后执行任务
            executor.schedule(new MyRunnable(1), 1, TimeUnit.SECONDS);
            
            // 延迟2秒后，每3秒执行一次任务
            executor.scheduleAtFixedRate(new MyRunnable(2), 2, 3, TimeUnit.SECONDS);
            
            // 关闭线程池
            executor.shutdown();
        }
    }
    
    class MyRunnable implements Runnable {
        private int id;
        
        public MyRunnable(int id) {
            this.id = id;
        }
        
        @Override
        public void run() {
            System.out.println("Task " + id + " is running on thread " + Thread.currentThread().getName());
        }
    }

在这个示例中，使用 BasicThreadFactory 来配置线程池。通过设置不同的属性，可以定制线程名、守护线程属性等。然后，使用 ScheduledThreadPoolExecutor 创建一个带有定时任务功能的线程池，并使用 schedule 和 scheduleAtFixedRate 方法添加定时任务。

使用第三方库的线程池封装可以帮助更方便地创建和管理线程池，以及提供一些额外的功能选项。