/// <summary>
        /// 将一个实现IThreadable的对象加入到主线程中,进行执行
        /// </summary>
        /// <param name="_threadable"></param>
        public void GoThreading(IThreadable _threadable)
        {
            if (_threadable.AlwaysUpdate)
            {
                alwaysUpdateQueue.Add(_threadable);
            }
            else
            {
                var type = _threadable.Type;

                if (baseThreads.ContainsKey(type))
                {
                    if (!baseThreads[type].Contains(_threadable))
                    {
                        baseThreads[type].Enqueue(_threadable);
                    }
                    else if (toCancel[type].Contains(_threadable))
                    {
                        toCancel[type].Remove(_threadable);
                    }
                    else
                    {
                        Debug.LogWarningFormat("{0} {1},在正在执行的情况下进行了RequestTick操作,这可能存在潜在的逻辑错误",
                                               type.ToString(), _threadable.ToString());
                    }
                }
                else
                {
                    //开辟新的线程
                    float maxTime = 0.001f; //1毫秒
                    var   attrs   = type.GetCustomAttributes(typeof(MainThreadingAttribute), true);
                    if (attrs != null && attrs.Length > 0)
                    {
                        var attr = (MainThreadingAttribute)attrs[0];
                        maxTime = attr.MaxTime * 0.001f;
                        if (!Application.isEditor)
                        {
                            maxTime *= (attr.ForFPS / 60);
                            maxTime  = Mathf.Min(attr.TopMostTime, maxTime);
                        }
                    }

                    baseThreads.Add(type, new Queue <IThreadable>());
                    toCancel.Add(type, new HashSet <IThreadable>());
                    maxTimeConsumptions.Add(type, maxTime);

                    //再执行一次,这样就直接开始了
                    GoThreading(_threadable);
                }
            }
        }
Exemple #2
0
        public void Add(string key, IThreadable thread)
        {
            if (_threadMap.TryRemove(key, out IThreadable beforeThread))
            {
                beforeThread.Stop();

                Console.WriteLine("Remove a thread.");
                LogManager.GetCurrentClassLogger().Info("Remove a thread.");
            }

            thread.Start();
            if (_threadMap.TryAdd(key, thread))
            {
                LogManager.GetCurrentClassLogger().Info("Add a thread.");
            }
        }
Exemple #3
0
        private int MAX_WAIT_TIME = 5 * 1000; // 5 seconds
        #endregion

        #region Constructor(s)
        public static ThreadHandler Instance(IThreadable threadableObject)
        {
            lock (_handlerListLock)
            {
                // It's better not to return null if shutdown already initiated
                // because most callers may not handle null, and that can result in an Exception.
                // The strategy is to return a new handler to the caller, but not let them start
                // a new thread

                string componentName = threadableObject.Name;
                if (!_threads.ContainsKey(componentName))
                {
                    var handler = new ThreadHandler();
                    handler._task            = threadableObject.Operation;
                    handler._waitHandle      = threadableObject.WaitHandle;
                    handler._abortHandle     = threadableObject.AbortHandle;
                    handler._cancelTaskToken = threadableObject.CancelTaskToken;
                    _threads.Add(componentName, handler);
                }
                return(_threads[componentName]);
            }
        }
        /// <summary>
        /// 取消一个对象的执行
        /// 注意,如果这个对象是UnityObject,那么不要在OnDestroy中调用
        /// 因为Threading检测到为空后,会自己删除掉
        /// 如果是其他类型,那么必须调用,否则Threading会保留一份引用,导致内存泄漏
        /// </summary>
        /// <param name="_threadable"></param>
        public void CancelThreading(IThreadable _threadable)
        {
            if (_threadable.AlwaysUpdate)
            {
                if (alwaysUpdateQueue.Count == 0)
                {
                    return;
                }

                var index = alwaysUpdateQueue.IndexOf(_threadable);
                if (index != -1)
                {
                    FastRemoveFromList(alwaysUpdateQueue, index);
                }
            }
            else
            {
                if (baseThreads.Count == 0)
                {
                    return;
                }

                var type = _threadable.Type;
                if (toCancel.ContainsKey(type))
                {
                    if (!baseThreads[type].Contains(_threadable))
                    {
                        Debug.LogWarningFormat("{0} {1},在没有执行的情况下进行了Quit操作,这没什么问题,但是尽量从逻辑上避免这种性能损耗。",
                                               type.ToString(), _threadable.ToString());
                    }
                    else
                    {
                        toCancel[type].Add(_threadable);
                    }
                }
            }
        }