关于并发下内存及cpu使用情况的思考

using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace ConsoleApp6
{
    
    public enum CoordinationStatus
    {
        AllDone,
        Timeout,
        Cancel
    };

    public sealed class AsyncCoordinator
    {
        private Int32 m_opCount = 1;        // Decremented when AllBegun calls JustEnded
        private Int32 m_statusReported = 0; // 0=false, 1=true
        private Action<CoordinationStatus> m_callback;
        private Timer m_timer;

        // This method MUST be called BEFORE initiating an operation
        public void AboutToBegin(Int32 opsToAdd = 1)
        {
            Interlocked.Add(ref m_opCount, opsToAdd);
        }

        // This method MUST be called AFTER an operations result has been processed
        public void JustEnded()
        {
            if (Interlocked.Decrement(ref m_opCount) == 0)
                ReportStatus(CoordinationStatus.AllDone);
        }

        // This method MUST be called AFTER initiating ALL operations
        public void AllBegun(Action<CoordinationStatus> callback, Int32 timeout = Timeout.Infinite)
        {
            m_callback = callback;
            // 是否需要永远运行
            if (timeout != Timeout.Infinite)
            {
                // 在指定的时间点(dueTime) 调用回调函数，随后在指定的时间间隔(period)调用回调函数
                m_timer = new Timer(TimeExpired, null, timeout, Timeout.Infinite);
            }
            JustEnded();
        }

        // 处理过时的线程
        private void TimeExpired(Object o)
        {
            ReportStatus(CoordinationStatus.Timeout);
        }

        public void Cancel()
        {
            if (m_callback == null)
                throw new InvalidOperationException("Cancel cannot be called before AllBegun");
            ReportStatus(CoordinationStatus.Cancel);
        }

        private void ReportStatus(CoordinationStatus status)
        {
            if (m_timer != null)
            {  // If timer is still in play, kill it
                Timer timer = Interlocked.Exchange(ref m_timer, null);
                if (timer != null) timer.Dispose();
            }

            // If status has never been reported, report it; else ignore it
            if (Interlocked.Exchange(ref m_statusReported, 1) == 0)
                m_callback(status);
        }
    }

    

    class Program
    {
        static AsyncCoordinator m_ac = new AsyncCoordinator();
        static void Main(string[] args)
        {
            Console.BufferHeight = Int16.MaxValue - 10;
            Console.BufferWidth = Int16.MaxValue - 10;

            ConcurrentQueue<int> concurrentQueue = new ConcurrentQueue<int>();

            for(int i =0;i<10000; i++)
            {
                concurrentQueue.Enqueue(i);
            }

            Console.WriteLine("添加完毕....");

            var t = new Task[50];
            
            for (int i=0; i<50; i++)
            {
                m_ac.AboutToBegin(1);
                t[i] = Task.Factory.StartNew((param) =>
                {
                    while (concurrentQueue.Count>0)
                    {
                        int x;
                        if(concurrentQueue.TryDequeue(out x))
                        {
                            Console.WriteLine(x + "   线程Id: {0},   线程数: {1}", Task.CurrentId, param.ToString());
                        }
                        //Thread.Sleep(150);
                    }
                    m_ac.JustEnded();
                }, i);
            }
            
            m_ac.AllBegun(AllDone, Timeout.Infinite);
            Console.ReadKey();
        }

        public static void AllDone(CoordinationStatus status)
        {
            switch (status)
            {
                case CoordinationStatus.Cancel:
                    Console.WriteLine("Operation canceled.");
                    break;

                case CoordinationStatus.Timeout:
                    Console.WriteLine("Operation timed-out.");
                    break;

                case CoordinationStatus.AllDone:
                    Console.WriteLine("处理完毕....");
                    break;
            }
        }
    }
}