并行流计算

以前自己理解中，只能把互不相关的计算进行并行化，提高计算速度，但是今天看书了解到了一个新的概念：流计算

比如计算： (i+j)*i/2
如果是单线程中执行同时只能计算一步，因为后面的计算是需要依赖前面的计算结果，所以没有办法完全并行化
并行流计算：
把上面计算拆3步：①i+j = x ② x * i = y ③ y/2
把三步分到不同线程计算，每一步计算完通知下一步，最终完成计算，这种方式如果只计算一次是不如串行的，如果是计算很多就相当于同时计算，只需一步就能计算出结果，就像工厂的流水线生产，而且还可以调节每一步的线程数
类1: 传输对象

public class Msg {
   public double i;

   public double j;

   public String orgString = null;
}

类2：计算第一步

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;

public class Plus implements Runnable {
    public static BlockingQueue<Msg> bq = new LinkedBlockingQueue<>();
    @Override
    public void run() {
        for(;;){
            try {
                Msg  msg = bq.take();
                msg.j = msg.i + msg.j;
                Multiply.bq.add(msg);
            } catch (InterruptedException e){
                e.printStackTrace();
            }

        }
    }

}

类3：计算第二步

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;

public class Multiply implements Runnable {
    public static BlockingQueue<Msg> bq = new LinkedBlockingQueue<>();
    @Override
    public void run() {
        for(;;){
            try {
                Msg msg = bq.take();
                msg.i = msg.i * msg.j;
                Div.bq.add(msg);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }

    }

}

类4：计算第三步

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;

public class Div implements Runnable {
    public static BlockingQueue<Msg> bq = new LinkedBlockingQueue<>();

    @Override
    public void run() {
        for (;;) {
            try {
                Msg msg = bq.take();
                msg.i = msg.i / 2;
                System.out.println(msg.orgString + "=" + msg.i);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }

    }

}

类5：main方法

public class Test {
    public static void main(String[] args) {
        new Thread(new Plus()).start();
        new Thread(new Multiply()).start();
        new Thread(new Div()).start();
        for (int i = 1; i <= 1000; i++) {
            for (int j = 1; j <= 1000; j++) {
                Msg msg = new Msg();
                msg.i = i;
                msg.j = j;
                msg.orgString = "((" + i + "+" + j + ")*" + i + ")/2";
                Plus.bq.add(msg);
            }
        }

    }
}

在这个案列中，这样计算肯定是没有单线程快，如果每一步计算都很耗时间，步骤很多，那对于速度的提升将是很大的。主要学习的是一个并行流计算思想。