多任务管理类 MutilTaskManager

最新推荐文章于 2025-09-06 21:58:22 发布

weixin_34396103

最新推荐文章于 2025-09-06 21:58:22 发布

阅读量65

点赞数

CC 4.0 BY-SA版权

文章标签：大数据

原文链接：http://www.cnblogs.com/jinzhao/archive/2012/03/21/2410191.html

本文介绍了一个多任务管理类，用于在大数据和大计算量场景下，通过限制并发任务数和队列长度来控制资源占用。提供了非线程安全和线程安全两个版本的实现。

计算和计算所需的数据能被较为平均的非配到若干task的时候，下面的任务管理类可以提供在大数据大计算量的情况下非精确的控制task的执行数量来限制计算量和内存占用量.

下面是代码（非线程安全版本）：

    public class MutilTaskManager
    {
        private readonly int _maxRun;
        private readonly int _maxQuenen;
        private List<Task> _taskRunningList;
        private readonly Queue<Task> _taskQueue;

        public bool IsQueueFull
        {
            get { return _taskQueue.Count > _maxQuenen; }
        }

        public MutilTaskManager(int maxRun = 8, int maxQuenen = 2)
        {
            _maxRun = maxRun;
            _maxQuenen = maxQuenen;
            _taskRunningList = new List<Task>(maxRun);
            _taskQueue = new Queue<Task>(2);
        }

        public void TakeBooting(int sleepTime = 10)
        {
            if (_taskRunningList.Count >= _maxRun)
            {
                _taskRunningList = _taskRunningList.Where(it => !it.IsCompleted).ToList();
            }
            while (_taskRunningList.Count < _maxRun && _taskQueue.Count > 0)
            {
                var t = _taskQueue.Dequeue();
                _taskRunningList.Add(t);
                t.Start();
            }
            System.Threading.Thread.Sleep(sleepTime);
        }

        public void Enqueue(Task task)
        {
            _taskQueue.Enqueue(task);
            TakeBooting(0);
        }

        public void WaitAll()
        {
            while (_taskQueue.Count > 0)
            {
                TakeBooting();
            }
            Task.WaitAll(_taskRunningList.ToArray());
        }
    }

线程安全版本：

public class MutilTaskManager
    {
        private readonly int _maxRun;
        private readonly int _maxQuenen;
        private List<Task> _taskRunningList;
        private readonly Queue<Task> _taskQueue;
        private object _lockObj = new object();
        public bool IsQueueFull
        {
            get { return _taskQueue.Count > _maxQuenen; }
        }

        public MutilTaskManager(int maxRun = 8, int maxQuenen = 2)
        {
            _maxRun = maxRun;
            _maxQuenen = maxQuenen;
            _taskRunningList = new List<Task>(maxRun);
            _taskQueue = new Queue<Task>(2);
        }

        public void TakeBooting(int sleepTime = 10)
        {
            lock (_lockObj)
            {
                if (_taskRunningList.Count >= _maxRun)
                {
                    _taskRunningList = _taskRunningList.Where(it => !it.IsCompleted).ToList();
                }
                while (_taskRunningList.Count < _maxRun && _taskQueue.Count > 0)
                {
                    var t = _taskQueue.Dequeue();
                    _taskRunningList.Add(t);
                    t.Start();
                }
            }
            System.Threading.Thread.Sleep(sleepTime);
        }

        public void Enqueue(Task task)
        {
            lock (_lockObj)
            {
                _taskQueue.Enqueue(task);
            }
            TakeBooting(0);
        }

        public void WaitAll()
        {
            while (_taskQueue.Count > 0)
            {
                TakeBooting();
            }
            Task.WaitAll(_taskRunningList.ToArray());
        }
    }

使用示例：

        void Test()
        {
            var mtm = new MutilTaskManager();
            foreach(int i in(new int[10]))
            {
                while (mtm.IsQueueFull)
                {
                    mtm.TakeBooting();
                }
                mtm.Enqueue(new Task(myTask));
            }
        }

        void myTask()
        {
            //read data
            //do something
        }

转载于:https://www.cnblogs.com/jinzhao/archive/2012/03/21/2410191.html