java多线程之流水线工厂模式

流水线工厂模式

一、简介

类似工厂中的流水线，一个产品要经过多道工序出炉。转换成线程知识就是，有一系列待处理工作，当一个线程完成一部分工作，下一个线程负责继续执行，这样多个线程协同工作完成总工作。

当我们需要对一个产品进行多次不同的操作时，比如我们要对一个队列List 进行加工，先将List传入T1工作间，加工完后，再传入T2、T3进行加工，最后得到成品。注意：List必须按照T1->T2->T3的顺序进行加工，否则为次品。

这时我们就用到流水线工厂模式进行加工。

当第一个产品到第一个工作间用时1个单位时间，再接着进入第二个工作间依次下去，就当第一个产品完成第一个工作间任务时，第二个进入一个工作间。假若这个产品需要加工4次，第一个成品出来花费4个单位时间，第二个成品出来则只需要1个单位时间。这就大大提高了效率。

二、代码

package pgs0204.thread.v1;

public class Task {
    int num;//40000
    boolean flagA;
    boolean flagB;
    boolean flagC;
    //ABC = 20 > 200 > 40000
    //ACB BCA CBA BAC
    public void taskA(){
        if(!flagA){
            num += 20;
            flagA = true;
        }
    }
    public void taskB(){
        if(flagA&&!flagB){
            num*=10;
            flagB = true;
        }
    }
    public void taskC(){
        if(flagB&&!flagC&&flagA){
            num *= num;
            flagC = true;
        }
    }
}
package pgs0204.thread.v1;

import java.util.ArrayList;

public class ThreadA implements Runnable{
    private ArrayList<Task> tasks;
    public ThreadA(ArrayList<Task> tasks){
        this.tasks = tasks;
    }
    //线程结束 就是run方法执行完成
    @Override
    public void run() {
        while(true){
            System.out.println("ThreadA ==== >");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            int count = 0;
            for (int i = 0; i < tasks.size(); i++) {
                Task task = tasks.get(i);
                task.taskA();
                if(task.flagA){
                    count++;
                }
            }
            if(count == tasks.size()){
                return;//结束当前线程
            }
        }
    }
}
class ThreadB implements Runnable{
    private ArrayList<Task> tasks;
    public ThreadB(ArrayList<Task> tasks){
        this.tasks = tasks;
    }

    @Override
    public void run() {
        while(true){
            System.out.println("ThreadB ==== >");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            int count = 0;
            for (int i = 0; i < tasks.size(); i++) {
                Task task = tasks.get(i);
                task.taskB();
                if(task.flagB){
                    count++;
                }
            }
            if(count == tasks.size()){
                return;
            }
        }
    }
}
class ThreadC implements Runnable{
    private ArrayList<Task> tasks;
    public ThreadC(ArrayList<Task> tasks){
        this.tasks = tasks;
    }

    @Override
    public void run() {
        System.out.println("ThreadC ==== >");
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        int count = 0;
        for (int i = 0; i < tasks.size(); i++) {
            Task task = tasks.get(i);
            task.taskC();
            if(task.flagC){
                count++;
            }
        }
        if(count == tasks.size()){
            return;
        }
    }
}

package pgs0204.thread.v1;

import java.util.ArrayList;

public class Manage {
    public static void main(String[] args) {
        //创建一个任务池
        ArrayList<Task> tasks = new ArrayList<>();
        for (int i = 0; i < 500; i++) {
            tasks.add(new Task());
        }
        //创建一个Runnable 实现类 对象
        //将任务池 传入 线程中
        ThreadA ta = new ThreadA(tasks);
        ThreadB tb = new ThreadB(tasks);
        ThreadC tc = new ThreadC(tasks);
        //创建一个Thread对象 启动线程
        Thread t1 = new Thread(ta);
        Thread t2 = new Thread(tb);
        Thread t3 = new Thread(tc);
        //同时启动的
        t1.start();
        t2.start();
        t3.start();
        //等待线程执行完成
        try {
            t1.join();
            t2.join();
            t3.join();
        }catch (InterruptedException e){
            throw new RuntimeException(e);
        }
        for (int i = 0; i < tasks.size(); i++) {
            System.out.println(tasks.get(i).num);
        }
    }
}

我们先设置三个任务，产品需要按顺序完成 任务A->任务B->任务C，所以成品就为num=40000。

为了能够完成顺序实现任务，我们在实现任务前做个判断。然后我们为这三个任务设置三个线程，在每个线程中的run方法里我们都设置了一个count来判断每个任务都必须实现。在主函数里我们创建一个队列来储存任务，并将任务传到每一个线程里来完成加工操作，然后调用start方法开起线程，再调用join方法等待所有线程都完成之后将每个成品打印出来。