基于newFixedThreadPool实现多线程案例

下面我来讲解一下基于newFixedThreadPool实现多线程的完整攻略。

一、ThreadPoolExecutor简介

在讲解newFixedThreadPool之前，先来介绍一下ThreadPoolExecutor。ThreadPoolExecutor是Java中的线程池框架，其实现了ExecutorService接口，可以通过线程池来管理多个线程，从而实现更高效的线程管理。

ThreadPoolExecutor在构造函数中提供了四个参数：corePoolSize、maximumPoolSize、keepAliveTime和workQueue。其中，corePoolSize指定核心线程池大小，maximumPoolSize指定最大线程池大小，keepAliveTime指定线程池中的线程空闲后的存活时间，workQueue则用于指定任务队列。这些参数的含义及作用可以根据实际业务需求自行调整。

二、newFixedThreadPool案例

newFixedThreadPool是ThreadPoolExecutor的一个静态方法，用于返回一个固定大小的线程池。其实现代码如下：

public static ExecutorService newFixedThreadPool(int nThreads) {
    return new ThreadPoolExecutor(nThreads, nThreads,
                                      0L, TimeUnit.MILLISECONDS,
                                      new LinkedBlockingQueue<Runnable>());
}

其中，nThreads为线程池的大小，LinkedBlockingQueue则是一个可阻塞的任务队列，用于存放任务。

下面我们来看一个基于newFixedThreadPool实现多线程的案例。在该案例中，我们定义了一个MyTask任务类，该类实现了Runnable接口，并重写了run方法。在run方法中，我们打印了当前线程名，并让线程休眠了一段时间。接着，我们通过newFixedThreadPool创建了一个大小为3的线程池，然后将任务交给线程池来管理。代码示例如下：

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Main {

    public static void main(String[] args) {
        ExecutorService executor = Executors.newFixedThreadPool(3);

        for (int i = 0; i < 10; i++) {
            MyTask task = new MyTask();
            executor.execute(task);
        }

        executor.shutdown();
    }

    static class MyTask implements Runnable {
        public void run() {
            System.out.println("Thread name: " + Thread.currentThread().getName());
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

在执行上述代码后，输出结果如下所示：

Thread name: pool-1-thread-1
Thread name: pool-1-thread-2
Thread name: pool-1-thread-3
Thread name: pool-1-thread-1
Thread name: pool-1-thread-2
Thread name: pool-1-thread-3
Thread name: pool-1-thread-1
Thread name: pool-1-thread-2
Thread name: pool-1-thread-3
Thread name: pool-1-thread-1

从输出结果可以看出，我们创建了一个大小为3的线程池，然后将10个任务交给线程池来管理。由于线程池的大小为3，因此每次只会有3个线程在执行任务，其他线程则在任务队列中等待。在上面的输出结果中，可以看到线程名为pool-1-thread-1、pool-1-thread-2、pool-1-thread-3的线程交替执行任务。

另外，如果想要在任务执行完后结束线程池，可以调用shutdown方法。该方法会等待线程池中的所有任务执行完毕后再关闭线程池。

三、另一个案例

下面再来看一个基于newFixedThreadPool实现多线程的案例。在该案例中，我们通过newFixedThreadPool创建了一个大小为5的线程池，然后将100个任务交给线程池来管理。在每个任务中，我们随机生成一个数字，并通过Thread.sleep方法来模拟处理时间。当线程池中的所有任务都处理完毕后，我们再打印出所有数字的和。代码示例如下：

import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class Main {

    public static void main(String[] args) throws Exception {
        ExecutorService executor = Executors.newFixedThreadPool(5);
        List<Future<Integer>> list = new ArrayList<>();

        for (int i = 0; i < 100; i++) {
            MyTask task = new MyTask();
            Future<Integer> future = executor.submit(task);
            list.add(future);
        }

        int sum = 0;
        for (Future<Integer> future : list) {
            sum += future.get();
        }
        System.out.println("sum: " + sum);

        executor.shutdown();
    }

    static class MyTask implements Runnable {
        public Integer call() throws Exception {
            Random random = new Random();
            int num = random.nextInt(100);
            Thread.sleep(num);
            return num;
        }
        public void run() {}
    } 
}

执行上述代码后，输出结果为：

sum: 4717

从输出结果可以看出，我们通过newFixedThreadPool创建了一个大小为5的线程池，然后将100个任务交给线程池来管理。在每个任务中，我们随机生成了一个数字，并通过Thread.sleep来模拟处理时间。当所有任务处理完毕后，我们计算所有数字的和，并打印出来。