Pipeline并行处理模型

前言

---

在我们平时的程序处理过程中，在效率上而言，串行处理的效率不如并行处理的效率，从线程层面而言，即多线程效率不如单线程。但是尽管说并行处理效率确实会比较高，但是它在处理拥有数据结果依赖关系的逻辑时，需要额外的同步管控。例如我的输出怎么临时被存放，然后被下游程序收到处理等等。倘若我们设计的并行处理程序能很好地解决，逻辑依赖关系，那么无疑并行处理的方式将会大大提速我们实际系统中的执行效率。本文笔者来聊聊其中一种被称为Pipeline(流水线)模式的并行处理作业模式，相信此并行处理模式在实际工作中还是有所应用场景的。

Pipeline并行处理模式概要

---

首先一个问题，什么叫做Pipeline并行处理模式呢？Pipeline并行处理模式，首先它具有Pipeline属性，它有一条完整的依赖关系处理流程。比如一道工序总共分3个流程，A，B和C， 并且有严格的先后顺序执行要求。B流程的执行必须依赖A流程的执行结果，同样C流程需要依赖B的。其实这么来看，串行处理模式是天然适用于Pipeline处理模式的。

不过本文我们要讨论的是并行处理Pipeline模式作业。如果按照惯常使用的多线程依赖同步的处理方法，主要有以下两种：

• 将程序中间结果写出到第三方存储介质内，然后并行处理线程与此第三方存储进行数据交互，同步。
• 程序中间结果保存到本地变量内，通过线程安全的做法将中间结果进行赋值输出，灵活一点的，还可以进行同步的控制。

接下来笔者将要讨论的方法是第二种方法。

车厢模拟式的Pipeline并行处理模式

---

这里我们将用模拟车厢的方式来进行Pipeline work的执行，每个车厢代表一个执行单元，车厢具有Pipeline work的独有特征：

• 车厢具有连接关系，每个车厢有它的前车厢和后车厢。
• 头车厢无前车厢，它的处理无须依赖前车厢执行结果。
• 尾车厢无后车厢，它的处理完毕即意味着总执行过程的结束。

另外在每个车厢内，它还具有以下变量：

• 多执行线程
• 中间结果置换列表

因此，基于车厢模型的Pipeline处理模式如下图所示：

上图中Middle Carriage(中部车厢)可能会有很多节，每个线程都有对应的中间结果输出列表。

Pipeline并行处理模式代码实现

---

此部分笔者来分享一段Pipeline并行处理模式的多线实现代码，引用自Hadoop社区JIRA的一个patch。

在这个patch代码中，还是沿用了上节车厢的概念，另外它的整个过程可拆分为以下几个步骤：

1. Pipeline work的定义以及Pipeline task的构建
2. 根据Pipeline task，来构建车厢
3. 车厢内部逻辑处理
   3.1) 头车厢(起始线程)处理过程
   3.2) 中部车(中部线程)厢处理过程
   3.3) 尾部车厢(末尾线程)处理过程

针对上述子步骤，我们逐一来阐述。首先是Pipeline work的定义，此work的是每个车厢的线程的具体执行逻辑。

    PipelineWork header = new PipelineWork<Object, TestItem>() {
      int idx = 0;

      @Override
      public TestItem doWork(Object obj) throws IOException {
        if (idx < items.size()) {
          TestItem item = items.get(idx);
          item.setVal(item.getVal() * 2);
          if (exp && (idx == items.size() - 1)) {
            throw ioe;
          }
          idx++;
          
          LOG.info(Thread.currentThread().getName() +
              ": Head worker produce item: " + item.getVal());
          return item;
        } else {
          LOG.info("Head worker finsihed produce item.");
          return null;
        }
      }
    };
    PipelineWork middle = new PipelineWork<TestItem, TestItem>() {
      @Override
      public TestItem doWork(TestItem item) {
        item.setVal(item.getVal() * 2);
        LOG.info(Thread.currentThread().getName() +
            ": Middle worker set value: " + item.getVal());

        return item;
      }
    };
    PipelineWork trailer = new PipelineWork<TestItem, Object>() {
      @Override
      public Object doWork(TestItem item) {
        item.setVal(item.getVal() * 2);
        LOG.info(Thread.currentThread().getName() +
            ": Trailer woker set value: " + item.getVal());

        return EMPTY;
      }
    };

然后根据上面的work，构建Pipeline task，

    PipelineTask task = new PipelineTask(conf, "pipeline.testcarriage");
    task.appendWork(header, "header");
    task.appendWork(middle, "middle" + i);
    task.appendWork(trailer, "trailer");
    task.kickOff();
    task.join();

在Pipeline的task的构建过程中，会进行车厢的组织，

  /**
   * Pipeline work的构建
   */
  public void kickOff() {
    for (int i = 0; i < pipeLine.size(); i++) {
      // 从pipeline中获取当前车厢
      Carriage ca = pipeLine.get(i);
      if (i == 0) {
    	// 第一个车厢为头车厢，没有前车厢，标记Header字段
        ca.setPrev(null);
        ca.setHeader();
      }
      if (i == pipeLine.size() - 1) {
    	// 如果是最后一节末尾车厢，则标记Trailer字段
        ca.setTrailer();
      }
      if (i > 0) {
    	// 中部车厢进行前车厢的引用赋值
        ca.setPrev(pipeLine.get(i - 1));
      }
      // 车厢衔接处理设置完毕，然后进行启动执行
      ca.kickOff();
    }
  }

每节车厢在组织完毕后，就可以开始run起来了。

对于每个车厢，它有如下的定义：

  private class Carriage<K, T> {
    private PipelineWork<K, T> work;
    private ArrayList<T>[] transferList;
    private ReentrantLock[] lock;
    private Throwable[] exception;
    // 每个线程的是否执行完毕的标识
    private boolean[] done;
    // 执行Carriage任务的线程数
    private int numThreads;
    private int blockingThreshold, transferThreshold, logThreshold;
    // 此车厢依赖的前车厢
    private Carriage prev;
    private volatile boolean shouldStop = false;
    final private List<T> EMPTY_LIST = new ArrayList<T>(0);
    // 是否是头车厢
    private boolean header = false;
    // 是否是末尾车厢
    private boolean trailer = false;
    // 执行当前车厢的线程组
    private Thread[] threads = null;
    private String name = null;
    ...
    
    public Carriage(PipelineWork<K, T> inWork, String caName) {
      name = caName;
      blockingThreshold = conf.getInt(getBlockingThresholdKey(name), 10000);
      transferThreshold = conf.getInt(getTransferThresholdKey(name), 100);
      logThreshold = conf.getInt(getLoggingThresholdKey(name), 10000000);
      numThreads = conf.getInt(getNumThreadsKey(name), 3);

      if (blockingThreshold < 0 || transferThreshold < 0
          || blockingThreshold < transferThreshold || logThreshold < 0
          || numThreads < 0) {
        throw new IllegalArgumentException("Illegal argument for PipelineTask "
            + name);
      }
      work = inWork;
      transferList = new ArrayList[numThreads];
      for (int i = 0; i < numThreads; i++) {
        transferList[i] = null;
      }
      lock = new ReentrantLock[numThreads];
      for (int i = 0; i < numThreads; i++) {
        lock[i] = new ReentrantLock();
      }
      exception = new Throwable[numThreads];
      for (int i = 0; i < numThreads; i++) {
        exception[i] = null;
      }
      done = new boolean[numThreads];
      for (int i = 0; i < numThreads; i++) {
        done[i] = false;
      }
    }

    public void setPrev(Carriage ca) {
      prev = ca;
      Preconditions.checkState(header == false);
    }

    public void stopCarriager() {
      shouldStop = true;
    }

    public void setHeader() {
      header = true;
      Preconditions.checkState(prev == null);
    }

    public void setTrailer() {
      trailer = true;
    }

    /**
     * 获取车厢的本地处理结果.
     */
    public List<T> getList() {
      int doneThread = 0;
      for (int i = 0; i < transferList.length; i++) {
        lock[i].lock();
        try {
          if (exception[i] != null) {
            return null;
          }
          // 如果发现i下标线程的中间结果列表不为空，则进行返回
          if (transferList[i] != null) {
            ArrayList<T> res = transferList[i];
            // 然后置空此下标值为空
            transferList[i] = null;
            return res;
          } else {
        	// 如果此下标置换列表为空，则判断是否为当前对应的线程已经处理完毕
            if (done[i]) {
              // 如果是，则进行技术加一
              doneThread++;
            }
          }
        } finally {
          lock[i].unlock();
        }
      }

      // 如果线程结束数量达到置换结果列表原始长度，则返回空，意为当前车厢数据已经完全处理完毕
      if (doneThread == transferList.length) {
        return null;
      } else {
    	// 否则，返回空list，意为暂时没有处理数据
        return EMPTY_LIST;
      }
    }

然后就是各个车厢内的并行处理的核心执行逻辑，

   /**
     * 执行车厢内容的线程类
     */
    private class CarriageThread extends Thread {
      // 线程标识
      private int index;

      public CarriageThread(int i) {
        index = i;
        this.setName("PipelineTask-" + name + "-" + index);
      }

    @Override
    public void run() {
      try {
          Preconditions.checkState((prev != null) ^ header);
          ArrayList<T> localList = null;
          if (!trailer) {
            localList =
                new ArrayList<T>((blockingThreshold > 0) ? blockingThreshold
                    : 0);
          }
          LOG.info("Carriage " + name + " thread " + index + " is scheduled");
          int itemHandled = 0;
          while (!shouldStop) {
            if (header) {
              /** 1.头车厢的处理过程 **/
              // 如果是头车厢，则没有前车厢依赖输入，直接执行
              T t = work.doWork(null);
              itemHandled++;
              if (itemHandled == logThreshold) {
                LOG.info("Handled " + itemHandled + " in " + name + " thread "
                    + index);
                itemHandled = 0;
              }
              if (!trailer && t != null) {
            	// 将处理结果加入到当前本地结果列表中
                localList.add(t);
              } else if (t == null) {
            	// 如果处理结果为空，意为原始输入数据已经完全处理完毕，头车厢任务宣告全部完成
                break;
              }
            } else {
               /** 2.中部车厢/尾车厢的处理过程 **/
              // 非头车厢，意为当前为中间车厢或者尾车厢，先取出前车厢的处理结果
              List<K> inputList = prev.getList();
              if (inputList == null) {
            	// 如果前车厢的处理结果为空，意为前车厢数据已处理完毕，则当前车厢跳出当前循环
            	LOG.info("Break out.");
                break;
              } else if (inputList.isEmpty()) {
            	// 如果前车厢的处理结果为Empty，意为前车厢还有未处理的数据，不过还未将结果赋值到置换列表内
            	// 让出当前CPU给其它线程执行
                Thread.yield();
                continue;
              }

              for (K k : inputList) {
            	// 遍历前车厢的数据处理结果，得到新的处理结果
                T t = work.doWork(k);
                itemHandled++;
                if (itemHandled == logThreshold) {
                  LOG.info("Handled " + itemHandled + " in " + name
                      + " thread " + index);
                  itemHandled = 0;
                }
                if (!trailer && t != null) {
                  // 将处理结果加入到当前车厢的本地结果列表内，将作为此车厢下节的依赖输入
                  // 后续同样是中间置换结果的赋值过程
                  localList.add(t);
                }
              }
            }
            if (trailer) {
              // 如果是尾车厢，跳过后续本地输出结果的交换
              continue;
            }
            
            /** 3.执行线程中间结果交换 **/
            // 如果当前本地结果超出阈值设定大小
            if (localList.size() >= transferThreshold) {
              if (lock[index].tryLock()) {
            	// 而且之前对应位置交换列表为空，则进行赋值
                if (transferList[index] == null) {
                  transferList[index] = localList;
                  lock[index].unlock();
                  // 交换完毕，重新置空本地结果列表
                  localList =
                      new ArrayList<T>(
                          (blockingThreshold > 0) ? blockingThreshold : 0);
                } else {
                  lock[index].unlock();
                }
              }
            }

            // 本地结果列表达到阻塞阈值设定大小，阻塞意为当前本地输出的结果必须要赋值到置换列表内
            if (blockingThreshold > 0 && localList.size() >= blockingThreshold) {
              lock[index].lock();
              // 如果当前置换列表数据不为空，意为还没被下游车厢处理，则进行循环等待
              while (transferList[index] != null) {
                lock[index].unlock();
                // 让出CPU给其它线程执行，然后再循环执行判断
                Thread.yield();
                lock[index].lock();
              }
              // 置换列表被下游车厢取走，则进行新的本地结果赋值
              transferList[index] = localList;
              lock[index].unlock();
              // 交换完毕，重新置空本地结果列表
              localList = new ArrayList<T>(blockingThreshold);
            }
          }

          /** 4.车厢末端中间结果赋值输出 **/
          // 循环执行结果后，将最后一批处理得到的本地输出结果进行输出赋值
          lock[index].lock();
          while (!trailer) {
            if (localList.size() > 0) {
              // 本地输出结果有值，并且置换列表为空，则进行辅助
              if (transferList[index] == null) {
                transferList[index] = localList;
                break;
              } else {
            	// 不为空，让出当前CPU给其它线程处理，然后再等待下次的循环处理
                lock[index].unlock();
                Thread.yield();
                lock[index].lock();
                continue;
              }
            } else {
              break;
            }
          }
          
          // 本地输入结果处理完毕，标记当前线程处理完毕
          done[index] = true;
          if (prev != null) {
            exception[index] = prev.getException();
          }
          lock[index].unlock();
        } catch (Throwable t) {
          // 更新对应下标线程信息的变量
          LOG.warn("Exception in pipeline task ", t);
          lock[index].lock();
          exception[index] = t;
          lock[index].unlock();
          shouldStop = true;
        }
        LOG.info("Carriage " + name + " thread " + index + " is done");
      }
    }

大家可以反复阅读上述的执行逻辑，设计还是比较巧妙的。

以下是其中的测试结果输出：每节车厢内的执行逻辑可以并行地run起来，无须强同步的控制。

2019-09-03 23:25:48,395 INFO util.TestPipelineTask (TestPipelineTask.java:doWork(69)) - PipelineTask-middle0-0: Middle worker set value: 2884
2019-09-03 23:25:48,395 INFO util.TestPipelineTask (TestPipelineTask.java:doWork(69)) - PipelineTask-middle0-0: Middle worker set value: 2888
2019-09-03 23:25:48,392 INFO util.TestPipelineTask (TestPipelineTask.java:doWork(69)) - PipelineTask-middle0-2: Middle worker set value: 1704
2019-09-03 23:25:48,392 INFO util.TestPipelineTask (TestPipelineTask.java:doWork(56)) - PipelineTask-header-0: Head worker produce item: 1976
2019-09-03 23:25:48,392 INFO util.TestPipelineTask (TestPipelineTask.java:doWork(79)) - PipelineTask-trailer-2: Trailer woker set value: 176
2019-09-03 23:25:48,395 INFO util.TestPipelineTask (TestPipelineTask.java:doWork(79)) - PipelineTask-trailer-2: Trailer woker set value: 192
2019-09-03 23:25:48,395 INFO util.TestPipelineTask (TestPipelineTask.java:doWork(79)) - PipelineTask-trailer-2: Trailer woker set value: 208
2019-09-03 23:25:48,395 INFO util.TestPipelineTask (TestPipelineTask.java:doWork(79)) - PipelineTask-trailer-2: Trailer woker set value: 232
2019-09-03 23:25:48,395 INFO util.TestPipelineTask (TestPipelineTask.java:doWork(56)) - PipelineTask-header-0: Head worker produce item: 1992
2019-09-03 23:25:48,395 INFO util.TestPipelineTask (TestPipelineTask.java:doWork(79)) - PipelineTask-trailer-0: Trailer woker set value: 16
2019-09-03 23:25:48,395 INFO util.TestPipelineTask (TestPipelineTask.java:doWork(69)) - PipelineTask-middle0-2: Middle worker set value: 1720
2019-09-03 23:25:48,395 INFO util.TestPipelineTask (TestPipelineTask.java:doWork(69)) - PipelineTask-middle0-0: Middle worker set value: 2892
2019-09-03 23:25:48,395 INFO util.TestPipelineTask (TestPipelineTask.java:doWork(69)) - PipelineTask-middle0-0: Middle worker set value: 2896

引用

---

[1].https://issues.apache.org/jira/browse/HDFS-13700 . The process of loading image can be done in a pipeline model