• 利于数组和单例模式进行均分，数组分发完，再次装填分发，以此循环分配

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

namespace WorkReceivOrder
{

    /// <summary>
    /// 任务分发
    /// </summary>
    public class ReceivOrder
    {

        /// <summary>
        /// 加锁
        /// </summary>
        private static readonly object _lock = new object();


        /// <summary>
        /// 开辟缓存,存储
        /// </summary>
        private static Dictionary<int, List<int>> _Implementers = new Dictionary<int, List<int>>();

        /// <summary>
        /// 获取组织编号
        /// </summary>
        /// <param name="orgid">组织编号</param>
        /// <returns></returns>
        private static List<int> Get_Implementers(int orgid)
        {

            if (_Implementers.TryGetValue(orgid, out List<int> values))
            {
                return values;
            }
            return new List<int>();
        }

        /// <summary>
        /// 设置执行分发人
        /// </summary>
        /// <param name="orgid">组织编号</param>
        /// <param name="reload">重新装填</param>
        private static void Set_Implementers(int orgid, bool reload = false)
        {
            //是否存在
            var nonExistent = false;
            //是否重载数组
            var existDict = false;

            if (reload)
            {
                nonExistent = true;
                existDict = true;
            }
            else if (_Implementers.Count == 0)
            {
                nonExistent = true;
            }
            else if (_Implementers.TryGetValue(orgid, out List<int> values))
            {
                if (values.Count == 0)
                {
                    nonExistent = true;
                }
                existDict = true;
            }
            if (nonExistent)
            {
                //这里操作数组
                //可用redis记录
                var v = new list<int>();

                    if (v.Count > 0)
                    {
   
                        if (existDict)
                        {
                            _Implementers[orgid] = _thisImplementerArr;
                        }
                        else
                        {
                            _Implementers.Add(orgid, _thisImplementerArr);
                        }
                    }
        }

        /// <summary>
        /// 执行人
        /// </summary>
        public static int Implementer(int orgid)
        {

            //初始化,只执行一次
            if (_Implementers.Count == 0 || !_Implementers.TryGetValue(orgid, out _))
            {
                Set_Implementers(orgid);
            }

            //执行人为空
            if (Get_Implementers(orgid).Count > 0)
            {
                lock (_lock)
                {
                    var Implementers = Get_Implementers(orgid);
                    if (Implementers.Count > 0)
                    {
                        var v = Implementers.First();

                        Implementers.RemoveAt(0);

                        //轮询后，进行装箱
                        if (Implementers.Count == 0)
                        {
                            Set_Implementers(orgid, true);
                        }
                        return v;
                    }
                }
            }
            return 0;
        }
    }
}