Java多线程之Worker Thread模式

什么是Worker Thread模式

Worker Thread模式是一种有效的多线程设计模式，用于在并发环境中处理多个请求，提高应用的响应性能和并发能力。

在Worker Thread模式中，主线程负责接收任务，把任务交给线程池中的工作线程去处理，主线程不断地接收任务，工作线程不断地从队列中取出任务并执行，一个任务只由一个工作线程处理，处理完毕后继续去取下一个任务。

如何使用Worker Thread模式

在Java中，使用Worker Thread模式一般需要按照以下步骤来实现：

1. 创建工作任务类：定义一个类，实现Runnable接口，实现工作线程需要执行的任务逻辑。

java
public class WorkTask implements Runnable {
@Override
public void run() {
// 执行任务逻辑
}
}

1. 创建线程池：调用ThreadPoolExecutor构造函数创建线程池，设置核心线程数、最大线程数、线程存活时间和任务队列等参数。

java
ExecutorService executor = new ThreadPoolExecutor(
corePoolSize, // 设置核心线程数
maximumPoolSize, // 设置最大线程数
keepAliveTime, TimeUnit.SECONDS, // 设置线程存活时间
new ArrayBlockingQueue<Runnable>(queueSize) // 设置任务队列
);

1. 提交任务：将任务提交给线程池执行。

java
executor.submit(new WorkTask());

1. 关闭线程池：任务执行完毕后需要关闭线程池，释放资源。

java
executor.shutdown();

示例说明

示例1：并发计算1到100的和

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

public class SumTask implements Runnable {
    private int start;
    private int end;
    private int result;

    public SumTask(int start, int end) {
        this.start = start;
        this.end = end;
    }

    public int getResult() {
        return result;
    }

    @Override
    public void run() {
        for (int i = start; i <= end; i++) {
            result += i;
        }
    }

    public static void main(String[] args) throws InterruptedException {
        ExecutorService executor = Executors.newFixedThreadPool(10);
        int totalCount = 0;
        for (int i = 1; i <= 10; i++) {
            int start = totalCount + 1;
            int end = totalCount + 10;
            executor.submit(new SumTask(start, end));
            totalCount += 10;
        }
        executor.shutdown();
        executor.awaitTermination(1, TimeUnit.HOURS);
        int sum = 0;
        while (!executor.isTerminated()) {
            // do nothing
        }
        for (int i = 1; i <= 10; i++) {
            SumTask task = (SumTask) executor.submit(new SumTask(i, i));
            sum += task.getResult();
        }
        System.out.println("sum is: " + sum);
    }
}

上面的代码实现了并发计算1到100的和的功能，大致过程如下：

1. 定义了一个SumTask类实现了Runnable接口，SumTask类的构造函数接收起始数值和结束数值，在run()方法中完成计算累加的操作。
2. 使用ExecutorService的newFixedThreadPool()方法创建了一个包含10个线程的线程池，每个线程负责从1到10、11到20、……、91到100计算和值。
3. 执行完所有任务之后，调用awaitTermination()方法等待所有任务执行完毕。
4. 计算各个线程的累加和，得到最终结果。

示例2：下载多个文件

import java.io.BufferedInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.net.URL;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

public class DownloadTask implements Runnable {
    private String url;
    private String filename;

    public DownloadTask(String url, String filename) {
        this.url = url;
        this.filename = filename;
    }

    @Override
    public void run() {
        try (BufferedInputStream in = new BufferedInputStream(new URL(url).openStream());
             FileOutputStream fileOutputStream = new FileOutputStream(filename)) {
            byte[] dataBuffer = new byte[1024];
            int bytesRead;
            while ((bytesRead = in.read(dataBuffer, 0, 1024)) != -1) {
                fileOutputStream.write(dataBuffer, 0, bytesRead);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) throws InterruptedException {
        ExecutorService executor = Executors.newFixedThreadPool(10);
        String[] urls = {
                "https://cdn.jsdelivr.net/npm/vue@2.6.12/dist/vue.min.js",
                "https://cdn.jsdelivr.net/npm/jquery@3.6.0/dist/jquery.min.js",
                "https://cdn.jsdelivr.net/npm/bootstrap@5.0.2/dist/js/bootstrap.min.js",
                "https://cdn.jsdelivr.net/npm/react@17.0.2/umd/react.production.min.js"
        };
        for (String url : urls) {
            executor.submit(new DownloadTask(url, url.substring(url.lastIndexOf("/") + 1)));
        }
        executor.shutdown();
        executor.awaitTermination(1, TimeUnit.MINUTES);
    }
}

上面的代码实现了下载多个文件的任务，大致过程如下：

1. 定义了一个DownloadTask类实现了Runnable接口，DownloadTask类的构造函数接收要下载的URL和文件名，在run()方法中完成下载的操作。
2. 使用ExecutorService的newFixedThreadPool()方法创建了一个包含10个线程的线程池，每个线程负责下载不同的文件。
3. 执行完所有任务之后，调用awaitTermination()方法等待所有任务执行完毕。

以上就是关于Java多线程之Worker Thread模式的完整攻略，希望能够帮助读者更好地理解这一设计模式及其相关应用。