用户模式构造-互锁构造

    internal enum CoordinationStatus { AllDone, Timeout, Cancel }

    /// <summary>
    /// 协调所有异步操作
    /// </summary>
    internal sealed class AsyncCoordinator
    {
        //AllBegun内部调用JustEnded来递减
        private int m_opCount = 1;
        //0为false，1为true
        private int m_statusReported = 0;

        private Action<CoordinationStatus> m_callback;

        private Timer m_timer;

        /// <summary>
        /// 该方法必须在发起一个操作之前调用
        /// </summary>
        /// <param name="opsToAdd"></param>
        public void AboutToBegin(int opsToAdd = 1)
        {
            //为多个线程共享的变量提供原子操作
            //对两个 32 位整数进行求和并用和替换第一个整数，上述操作作为一个原子操作完成
            // 参数:
            //   location1:
            //     一个变量，包含要添加的第一个值。 两个值的总和存储在 location1。
            //
            //   value:
            //     要添加到整数的值 location1。
            //
            // 返回结果:
            //     新值存储在 location1。
            Interlocked.Add(ref m_opCount, opsToAdd);
        }

        /// <summary>
        /// 该方法必须在处理好一个操作的结果之后调用
        /// </summary>
        public void JustEnded()
        {
            //为多个线程共享的变量提供原子操作
            //以原子操作的形式递减指定变量的值并存储结果
            // 参数:
            //   location:
            //     其值要递减的变量。
            //
            // 返回结果:
            //     递减的值。
            if (Interlocked.Decrement(ref m_opCount) == 0)
            {
                ReportStatus(CoordinationStatus.AllDone);
            }
        }

        /// <summary>
        /// 该方法必须在发起所有操作之后调用
        /// </summary>
        /// <param name="action"></param>
        /// <param name="timeout"></param>
        public void AllBegun(Action<CoordinationStatus> action, int timeout = Timeout.Infinite)
        {
            m_callback = action;

            //若不是无限等待
            if (timeout != Timeout.Infinite)
            {
                m_timer = new Timer(TimeExpired, null, timeout, Timeout.Infinite);
            }

            JustEnded();
        }

        /// <summary>
        /// 取消
        /// </summary>
        public void Cancel()
        {
            ReportStatus(CoordinationStatus.Cancel);
        }

        /// <summary>
        /// 超时
        /// </summary>
        /// <param name="obj"></param>
        private void TimeExpired(object obj)
        {
            ReportStatus(CoordinationStatus.Timeout);
        }

        /// <summary>
        /// 报告状态
        /// </summary>
        /// <param name="status"></param>
        private void ReportStatus(CoordinationStatus status)
        {
            //如果状态从未报告过就报告它，否则忽略它
            //为多个线程共享的变量提供原子操作
            //以原子操作的形式，将 32 位有符号整数设置为指定的值并返回原始值
            // 参数:
            //   location1:
            //     要设置为指定值的变量。
            //
            //   value:
            //     location1 参数要设置成的值。
            //
            // 返回结果:
            //     location1 的原始值。
            if (Interlocked.Exchange(ref m_statusReported, 1) == 0)
            {
                m_callback(status);
            }
        }
    }

    internal sealed class MultiWebRequests
    {
        //用于协调所有异步操作
        private AsyncCoordinator m_AsyncCoordinator = new AsyncCoordinator();

        //想要查询的Web服务器及其响应（异常或int）的集合
        //多个线程访问该字典时不需要同步进行，因为构造后键是只读的
        private Dictionary<string, object> m_servers = new Dictionary<string, object>
        {
            {"http://referencesource.microsoft.com/",null },
            {"https://msdn.microsoft.com/zh-CN/",null },
            {"https://www.microsoft.com/net",null },
            {"http://www.songtaste.com/",null }
        };

        public MultiWebRequests(int timeout = Timeout.Infinite)
        {
            //以异步方式，一次性发起所有请求
            var httpClient = new HttpClient();
            foreach (var server in m_servers.Keys)
            {
                m_AsyncCoordinator.AboutToBegin(1);
                httpClient.GetByteArrayAsync(server).ContinueWith(task => ComputeResult(server, task));
            }

            //告诉AsyncCoordinator 所有操作均已发起
            //并在所有操作完成或调用Cancel或超时时调用AllDone
            m_AsyncCoordinator.AllBegun(AllDone, timeout);
        }

        private void ComputeResult(string server, Task<byte[]> task)
        {
            Object result;
            if (task.Exception != null)
            {
                result = task.Exception.InnerException;
            }
            else
            {
                result = task.Result.Length;
            }

            //保存结果，指出1个操作完成
            m_servers[server] = result;
            m_AsyncCoordinator.JustEnded();
        }

        /// <summary>
        /// 调用这个方法指出结果已无关紧要
        /// </summary>
        public void Cancel()
        {
            m_AsyncCoordinator.Cancel();
        }

        //所有服务器都响应、调用了Cancel或发生了超时就调用该方法
        private void AllDone(CoordinationStatus status)
        {
            switch (status)
            {
                case CoordinationStatus.AllDone:
                    Console.WriteLine("Completed");
                    foreach (var server in m_servers)
                    {
                        Console.Write("{0} ", server.Key);
                        object result = server.Value;
                        if (result is Exception)
                        {
                            Console.WriteLine("Failed due to {0}.", result.GetType().Name);
                        }
                        else
                        {
                            Console.WriteLine("Returned {0:N0} bytes.", result);
                        }
                    }
                    break;
                case CoordinationStatus.Timeout:
                    Console.WriteLine("Timeout");
                    break;
                case CoordinationStatus.Cancel:
                    Console.WriteLine("Cancelled");
                    break;
                default:
                    break;
            }
        }
    }

m_opCount字段初始化为1（而非0），执行构造器方法的线程在发出Web服务器请求期间，由于m_opCount为1，所以能保证AllDone不会被调用，构造器调用AllBegun之前，m_opCount不可能变成0。构造器调用AllBegun时，AllBegun内部调用JustEnded来递减m_opCount，所以事实上撤销了把它初始化成1的效果，现在m_opCount能变成0了，但只能是在发起了所有Web服务器请求之后。