java项目-流水线线程池

项目效果：

实现生产者生成任务，线程池A接受并且处理任务，接着传递给B，B处理过后给C，最终实现流水线处理效果

项目构成：一个主线程类Main，三个任务类TaskABC，一个任务处理底层逻辑类Task

代码实现：

1.Main类

任务处理线程+监听线程

java 复制代码

import java.util.ArrayList;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.Executor;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/**
 * @author jinhuang
 * @date 2026/5/23  15:37
 * @description ${DESCRIPTION}
 */// Press Shift twice to open the Search Everywhere dialog and type `show whitespaces`,
// then press Enter. You can now see whitespace characters in your code.
public class Main {
    public static void main(String[] args) {
        // 固定任务量
        ArrayBlockingQueue<Runnable> queueA = new ArrayBlockingQueue<>(20);
        ArrayBlockingQueue<Runnable> queueB = new ArrayBlockingQueue<>(20);
        ArrayBlockingQueue<Runnable> queueC = new ArrayBlockingQueue<>(20);
        ArrayList<Task> taskDoneList = new ArrayList<>();
        //创建三个线程池
        Executor executorA=new ThreadPoolExecutor(5,10,1000, TimeUnit.MILLISECONDS,queueA);
        Executor executorB=new ThreadPoolExecutor(5,10,1000, TimeUnit.MILLISECONDS,queueB);
        Executor executorC=new ThreadPoolExecutor(5,10,1000, TimeUnit.MILLISECONDS,queueC);


        //生产者实时生成任务处理
        new Thread(()->{
            int count=0;
            while (true){
                try {
                    Thread.sleep(50);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                Task task=new Task();
                executorA.execute(new TaskA(executorB,executorC,taskDoneList,task));
                count++;
                System.out.println("生产者"+count);
            }
        }).start();

        //监控线程
        new Thread(()->{
            while(true){
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                System.out.println("队列A大小：" + queueA.size() + " 队列B大小：" +
                        queueB.size() + " 队列C大小：" + queueC.size());
                int count = 0;
                for (int i = 0; i < taskDoneList.size(); i++) {
                    if (taskDoneList.get(i).num == 40000) {
                        count++;
                    }
                }
                System.out.println("已完成的任务数量：" + taskDoneList.size() + "正确的数量"+ count);
            }}).start();
        }
            }

2.TaskABC

核心在于任务在线程池BC中的传递，通过execute方法实现

java 复制代码

import java.util.ArrayList;
import java.util.concurrent.Executor;

/**
 * @author jinhuang
 * @date 2026/5/23  15:39
 * @description
 */
public class TaskA implements Runnable{
    Executor executorB;
    Executor executorC;
    ArrayList<Task> taskDoneList;
    Task task;
    //初始化TaskA
    public TaskA(Executor B,Executor C,ArrayList<Task> taskDoneList,Task task) {
        this.executorB = B;
        this.executorC = C;
        this.taskDoneList = taskDoneList;
        this.task = task;
    }

    @Override
    public void run() {
        task.taskA();
        // 将执行完的任务提交给线程池B
        executorB.execute(new TaskB(task, executorC, taskDoneList));
    }
}
class TaskB implements Runnable{
    Task task;
    Executor executorC;
    ArrayList<Task> taskDoneList;
    public TaskB(Task task, Executor executorC, ArrayList<Task> taskDoneList) {
        this.task = task;
        this.executorC = executorC;
        this.taskDoneList = taskDoneList;
    }
    @Override
    public void run() {
        task.taskB();
// 将执行完的任务提交给线程池C
        executorC.execute(new TaskC(task, taskDoneList));
    }
}

class TaskC implements Runnable{
    Task task;
    ArrayList<Task> taskDoneList;
    public TaskC(Task task, ArrayList<Task> taskDoneList) {
        this.task = task;
        this.taskDoneList = taskDoneList;
    }
    @Override
    public void run() {
        task.taskC();
        taskDoneList.add(task);
    }
}

3.Task类

这个类中定义了三个任务流水线的工序

java 复制代码

public class Task {
    int num;
    public void taskA()  {
        try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        num+=20;
    }

    public void taskB(){
        try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        num*=10;
    }

    public void taskC(){
        try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        num*=num;
    }
}