具有依赖关系的并行操作执行

今天看到看到一篇MSDN文章《Parallelizing Operations With Dependencies》,作者是微软Parallel Computing Platform团队的一个开发经理。文中提供出一种用于并行执行一组具有依赖关系的操作的解决方案，这不由得想起我在一年之前写的一个具有相同的功能的组件。于是翻箱倒柜找了出来，进行了一些加工，与大家分享一下。

一、问题分析

我们知道，较之串行化的操作，并行计算将多个任务同时执行，从而充分利用了资源，提高了应用的整体性能。对于多个互不相干的操作，我们可以直接按照异步的方式执行就可以。但是，我们遇到的很多情况下是，部分操作之间具有相互依赖的关系，一个操作需要在其他依赖的操作执行完成后方可执行。 以下图为例，每一个圆圈代表要执行的操作，操作之间的肩头代表它们之间的依赖关系。

我们需要一个组件，帮助我们完成这样的工作：将相应的操作和依赖关系直接添加到一个容器中，我们的组件能够自动分析操作之间的依赖关系，在执行的时候根据依赖编排执行顺序。

二、采用并行操作执行器

使用我所提供的这样一个并行操作执行器（ParallelExecutor），可以帮我们解决这个问题。首先对操作本身进行抽象，用以下三个属性来描述一个并行计算场景中的操作：

•  Operation ID: 操作的唯一标识，字符类型
•  Action：操作具体执行的功能，使用Action代理表示
•  Depedencies：依赖操作列表

在使用ParallelExecutor对操作进行并行执行之前，我们需要通过ParallelExecutor的两个AddOperation方法添加需要执行的操作。AddOperation定义如下。其中dependencies代表以来操作ID数组，返回值为当前创建的操作ID。

public class ParallelExecutor
{

    public string AddOperation(string id, Action action)
    {
        //省略实现
    }

    public string AddOperation(string id, Action action, string[] dependencies)
    {
        //省略实现
    }
}

对于上图中的操作的依赖结构，我们通过下面的代码将所有的操作添加到创建的ParallelExecutor之中并执行。在这里的具体实现的操作仅仅是打印出操作的ID，以便我们清楚地知道操作执行的先后顺序是否满足依赖关系：

static void Main(string[] args)
{
    Action<string> action = id=> {Console.WriteLine(id);};

    var executor = new ParallelExecutor();
    var a1 = executor.AddOperation("A1", () => action("A1"));
    var a2 = executor.AddOperation("A2", () => action("A2"));
    var a3 = executor.AddOperation("A3", () => action("A3"));

    var b1 = executor.AddOperation("B1", () => action("B1"), new string[] { a1, a2 });
    var b2 = executor.AddOperation("B2", () => action("B2"), new string[] { a3 });

    var c1 = executor.AddOperation("C1", () => action("C1"), new string[] { b1,b2 });
    var c2 = executor.AddOperation("C2", () => action("C2"));

    executor.Execute();
Console.Read();
}

由于是操作的并行执行，线程调度的不确定性使每次输出的结果各有不同。但是无论如何，需要满足上图中展现的依赖关系。下面是其中一种执行结果，可以看出这是合理的执行顺序。

A3
B2
A1
A2
C2
B1
C1

三、操作是如何被执行的

实现这样的并行计算有很多种解决方案。不同的解决方案大都体现在对于单一的操作该如何执行上。在我们提供这个解决方案中，我按照这样的方案来执行任意一个操作：

直接执行无依赖的操作

如果需要执行的操作并不依赖于任何一个操作（比如C2），那么我们直接运行就好了，这没有什么好说的。

先执行依赖操作，通过注册事件的方式执行被依赖的操作

如果一个操作依赖于一组操作，在执行之前注册依赖操作的结束事件实现，被依赖操作的执行发生在某个一个依赖操作的Completed事件触发后。具体来讲，上图中C1具有两个以来操作B1和B2，在初始化时，C1上会有一个用于计算尚未执行的依赖操作的个数，并注册B1和B2得操作结束事件上面。当B1和B2执行结束后，会触发该事件。每次事件触发，C1上的计数器将会减1，如果计数器为0，则表明所有的依赖操作执行结束，则执行C1相应的操作。

四、具体实现

现在我们来看看详细设计和具体实现。首先通过下面的类图看看涉及到的所有类型。其中Operation类型是最为重要的一个类型，它代表一个具体的操作。

操作的属性

一个操作具有如下属性：

• ID：String类型，操作的唯一标识
• Action：Action类型，操作具体是实现的功能
• Dependencies：Operation数组，依赖的操作
• Status：Operation枚举，操作当前的状态
• ExecutionContext：ExecutionContext类型，用于传递线程执行的上下文
  

public class Operation
{
    //其他成员
    public string ID
    { get; private set; }

    public Action Action
    { get; private set; }

    public Operation[] Dependencies
    { get; private set; }

    public OperationStatus Status
    { get; private set; }

    public ExecutionContext ExecutionContext
    { get; private set; }

    public Operation(string id, Action action)
    {
        if (string.IsNullOrEmpty(id))
        {
            throw new ArgumentNullException("id");
        }

        if (null == action)
        {
            throw new ArgumentNullException("action");
        }
        this.Status = OperationStatus.Created;
        this.ID = id;
        this.Action = action;
        this.Dependencies = new Operation[0];
    }

    public Operation(string id, Action action, Operation[] dependencies)
        : this(id, action)
    {
        if (null == dependencies)
        {
            throw new ArgumentNullException("dependencies");
        }

        this.Dependencies = dependencies;
    }
}

操作事件

当前操作执行的状态通过OperationStatus表示，四个枚举值分别表示被创建、正在运行、运行结束和失败（抛出异常）。

public enum OperationStatus
{
    Created,
    Running,
    Completed,
Failed
}

操作还具有三个时间，分别在开始执行、结束执行和执行失败时触发。这三个事件名称分别为OperationStarted、OperationCompleted和OperationFailed。

public class Operation
{
    //其他成员
    public event EventHandler<OperationEventArgs> OperationStarted;
    public event EventHandler<OperationFailedEventArgs> OperationFailed;
    public event EventHandler<OperationEventArgs> OperationCompleted;
}

OperationStarted和OperationCompleted事件对应的参数类型为OperationEventArgs。OperationEventArgs直接继承自EventArgs，并定义了一个Operation属性代表对应的Operation对象。

public class OperationEventArgs : EventArgs
{
    public OperationEventArgs(Operation operation)
    {
        if (null == operation)
        {
            throw new ArgumentNullException("operation");
        }

        this.Operation = operation;
    }

    public Operation Operation
    { get; private set; }
}

OperationFailed的事件参数类型为OperationFailedEventArgs。继承自OperationEventArgs，在此基础上添加了一个Exception类型的Error属性，表示抛出的异常。

操作初始化和事件注册

在第三节中已经谈到过了，被依赖操作的执行通过的依赖操作执行完成后触发OperationCompleted事件的是实现。事件注册必须在ParallelExecutor执行之前完成，在这里我定义了一个Initialize方法，在里面完成事件注册工作：

public class Operation
{
    //其他成员
    private int _remainingDependencies;
    private List<Operation> _registeredParentOps = new List<Operation>();

    private static void RegisterCompletedEvents(Operation operation)
    {
        operation._remainingDependencies = operation.Dependencies.Length;
        foreach (var op in operation.Dependencies)
        {
            if (op._registeredParentOps.Contains(operation))
            {
                continue;
            }
            RegisterCompletedEvents(op);
            op.OperationCompleted += (sender, args) =>
                {
                    operation._remainingDependencies--;
                    if (operation._remainingDependencies <= 0)
                    {
                        operation.DoExecute();
                    }
                };
            op._registeredParentOps.Add(operation);
        }
    }

    public void Initialize()
    {
        RegisterCompletedEvents(this);
   }
}

操作执行

ParallelExecutor通过调用Operation的Execute方法执行相应的操作。在Execute方法中，如果是独立的操作，则执行执行，否则异步执行依赖操作，这是一个递归的过程。操作的具体实现定义在DoExecute方法中。

public class Operation
{
    //其他成员
    private void DoExecute()
    {
        if (this.Status != OperationStatus.Created)
        {
            return;
        }

        if (null != this.OperationStarted)
        {
            this.OperationStarted(this, new OperationEventArgs(this));
        }

        this.Status = OperationStatus.Running;
        try
        {
            if (null != this.ExecutionContext)
            {
                ExecutionContext.Run(this.ExecutionContext.CreateCopy(), state => this.Action(), null);
            }
            else
            {
                this.Action();
            }

            this.Status = OperationStatus.Completed;
            if (null != this.OperationCompleted)
            {
                this.OperationCompleted(this, new OperationEventArgs(this));
            }
        }
        catch (Exception ex)
        {
            this.Status = OperationStatus.Failed;
            if (null != this.OperationFailed)
            {
                this.OperationFailed(this, new OperationFailedEventArgs(this, ex));
            }
        }
    }

    [MethodImplAttribute(MethodImplOptions.Synchronized)]
    public void Execute()
    {
        if (this.Dependencies.Length == 0)
        {
            this.DoExecute();
        }

        foreach (var operation in this.Dependencies)
        {
            var op = operation;
            ThreadPool.UnsafeQueueUserWorkItem(state => op.Execute(), null);
        }

    }
}

ParallelExecutor

ParallelExecutor提供操作的添加和整体执行。添加操作实现在两个重载的AddOperation方法中，逻辑并不复杂。当执行Execute方法对所有的操作进行并行执行的时候，需要调用Initialize方法对每个操作进行初始化。然后异步调用每个操作的Execute方法即可。

public class ParallelExecutor
{
    public ParallelExecutor()
    {
        this.Operations = new Dictionary<string, Operation>();
    }

    public IDictionary<string, Operation> Operations
    { get; private set; }

    public void Execute()
    {
        foreach (var operation in this.Operations.Values)
        {
            operation.Initialize();
        }

        foreach (var operation in this.Operations.Values)
        {
            var op = operation;
            ThreadPool.UnsafeQueueUserWorkItem(state => op.Execute(), null);
        }
    }

    public string AddOperation(string id, Action action)
    {
        ValidateOperation(id, action);
        this.Operations.Add(id, new Operation(id, action));
        return id;
    }

    private void ValidateOperation(string id, Action action)
    {
        if (null == action)
        {
            throw new ArgumentNullException("action");
        }

        if (this.Operations.ContainsKey(id))
        {
            throw new ArgumentException(string.Format("There is an existing operation whose ID is \"{0}\"", id));
        }
    }

    public string AddOperation(string id, Action action, string[] dependencies)
    {
        ValidateOperation(id, action);
        if (null == dependencies)
        {
            throw new ArgumentNullException("dependencies");
        }

        foreach (var op in dependencies)
        {
            if (!this.Operations.ContainsKey(op))
            {
                throw new ArgumentException(string.Format("The operation whose ID is \"{0}\" does not exist!", op));
            }
        }

        var operation = new Operation(id, action,
               this.Operations.Values.
               Where(op => Array.Exists<string>(dependencies, opId => opId == op.ID)).ToArray<Operation>());

        this.Operations.Add(id, operation);
        return id;
    }
}

---

作者：Artech
出处：http://artech.cnblogs.com
本文版权归作者和博客园共有，欢迎转载，但未经作者同意必须保留此段声明，且在文章页面明显位置给出原文连接，否则保留追究法律责任的权利。