工厂流水线模式

今天要使用Java中的多线程进行模拟工厂的流水线工作模式

Java菜鸟的第一份博客，有一些不到位的地方，请各位大佬指点(抱拳！！！)

制作流程

1、模拟需要加工的内容
2、实现加工处理的方法
3、使用多线程的方式实现流水线模型
4、模拟工人对象进行工作

所需知识

1、成员变量、构造方法、功能方法的实现
2、线程的创建
3、线程中方法的使用

实现过程

1、创建成员变量及其构造方法

    private int num;//创建一个数字变量
    
	public Task(int num) {//有参方法
        this.num = num;
    }
    
    public int getNum() {//get方法
        return num;
    }

    public void setNum(int num) {//set方法
        this.num = num;
    }

    public Task() {//无参方法
    }
    

2、创建需要进行运算的方法

 public void Sum(int num)//加法运算
    {
        int before = getNum();
        int after = before +num;
        setNum(after);//得到结果对其进行修改
    }
    
    public void Mul(int num)//乘法运算
    {
        int before = getNum();
        int after = before *num;
        setNum(after);
    }
    
    public  void Mul1(int num)//和自己相乘
    {
        int before = getNum();
        int after = before*before;
        setNum(after);
    }
}

3、创建线程

class TaskA extends Thread{
	//创建TaskA类继承Thread类
    public TaskA(Task task) {//设定TaskA的有参方法，给外部提供获取方式
        this.task = task;
    }
    private Task task;//设定Task为私有变量
    public void run()//重写Thread中的run()方法
    {
        task.Sum(10);//传一个需要运算的值
        System.out.println("当前运算完成，当前数值为"+task.getNum());
    }
}

class TaskB extends Thread{

    public TaskB(Task task) {
        this.task = task;
    }

    private Task task;

    public void run(){
        int def = 20;
        task.Mul(def);
        System.out.println("当前运算完成，当前数值为"+task.getNum());
    }
}

class TaskC extends Thread{

    public TaskC(Task task) {
        this.task = task;
    }

    private Task task;

    @Override
    public void run() {
        int def = task.getNum();
        task.Mul1(def);
        System.out.println("当前运算完成，当前数值为"+task.getNum());
    }
}

需求： 1、给定一个值num
2、对num进行以下运算

num+=10;
num*=20;
num*=num;

根据初步的计算，我们得出最后的结果是40000 下面我们对其进行模拟测试

4、直接进行线程的运行会出现什么情况呢？

public class Task {
    public static void main(String[] args) {
        Task task = new Task(0);
        Thread thread = new TaskA(task);
        thread.setName("线程A");
        thread.start();

//        try {
//            Thread.sleep(2000);
//        } catch (InterruptedException e) {
//            e.printStackTrace();
//        }

        Task task1 = new Task(task.getNum());
        Thread thread1 = new TaskB(task1);
        thread1.setName("线程B");
        thread1.start();

//        try {
//            Thread.sleep(2000);
//        } catch (InterruptedException e) {
//            e.printStackTrace();
//        }
        Task task2 = new Task(task1.getNum());
        Thread thread2 = new TaskC(task2);
        thread2.setName("线程C");
        thread2.start();

    }

这里就出现了，虽然三个线程都是互不干扰的，但是有一个关键点就是，第二个步骤是需要第一个步骤计算过之后才能够计算的，第三个步骤也是如此。

进过上面的调试我们的出，需要在中间等待上一步结束，让下一步拿到上一步的值在进行运算 我们在此加入了Thread.sleep()方法
该方法的功能就是让其睡眠一会

5、创建上述3个线程对象运行

public class Task {

    public static void main(String[] args) {
    
        Task task = new Task(0);//设定初始值
        Thread thread = new TaskA(task);//创建线程对象，把task对象传到TaskA中
        thread.setName("线程A");//修改线程的名字
        thread.start();//启动线程A线程

        try {
            Thread.sleep(2000);//当前线程睡眠2秒
            //此处有运行时异常需要处理
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        Task task1 = new Task(task.getNum());//创建Task对象，获取task运算完毕之后的值
        Thread thread1 = new TaskB(task1);//创建线程，把task1传入TaskB中
        thread1.setName("线程B");//修改线程名
        thread1.start();//启动线程B线程

        try {
            Thread.sleep(2000);//睡眠2秒钟
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        
        Task task2 = new Task(task1.getNum());//创建Task对象，获取task1运算完毕之后的值
        Thread thread2 = new TaskC(task2);//创建线程，把task2传入TaskC中
        thread2.setName("线程C");//修改线程名
        thread2.start();//启动线程C线程

    }

最后实现的结果是这样：
由于我们之前设定了睡眠2秒的设定(也可以算是等待时间)，所以，屏幕内的第一行会先输出，之后第二行输出，最后第三行输出
如果没有设定睡眠时间的话，就会出现下面的一个场景 工人A还没做完的活，工人B就把还没加工的作业拿走了，工人B没完成工人C拿走了作业
所以为了没有上述冲突，我们采用了模拟网络延迟的功能(等待时间)

总结：
1、了解线程创建需要的条件
2、在线程上模拟了工人流水线中可能会出现的情况
3、巩固了之前对象创建，继承，成员变量的知识