예제 #1
0
        /// <summary>
        /// Timer的主要处理函数,用来计算是否需要处理的时候了
        /// </summary>
        private static void RunTimerThread()
        {
            // 向服务程序注册有新的线程在内部运行
            OneServer.BeginRegisterThread();

            LOGs.WriteLine(LogMessageType.MSG_INFO, LanguageString.SingletonInstance.TimerThreadString007);

            long     iIndex      = 0;
            bool     bLoaded     = false;
            DateTime nowDateTime = DateTime.Now;

            while (OneServer.Closing == false)
            {
                s_Signal.WaitOne(10, false);

                // 服务已经关闭则退出
                if (OneServer.Closing == true)
                {
                    break;
                }

                // 百分比输出显示
                if (s_IsDumpInfo == true)
                {
                    s_IsDumpInfo = false;
                    InternalDumpInfo();
                }

                // 先处理改变了优先级的时间片集合
                ProcessChangeQueue();

                bLoaded = false;

                // 8种时间片
                for (iIndex = 0; iIndex < 8; iIndex++)
                {
                    nowDateTime = DateTime.Now;

                    // 如果小于下一次处理的时间片就跳出
                    if (nowDateTime < s_NextPriorities[iIndex])
                    {
                        break;
                    }

                    // 设置下一次处理的时间片
                    s_NextPriorities[iIndex] = nowDateTime + s_PriorityDelays[iIndex];

                    foreach (KeyValuePair <TimeSlice, TimeSlice> timeSlice in s_Timers[iIndex])
                    {
                        // 如果当前时间片已经处理过,已不在先入先出的集合中,并且当前的时间大于下一次调用的时间
                        if (timeSlice.Value.InQueued == false && nowDateTime > timeSlice.Value.NextTime)
                        {
                            // 表示将当前的时间片已经加入先入先出集合中
                            TimeSlice.JoinProcessQueue(timeSlice.Value);

                            bLoaded = true;

                            // 如果运行次数大于等于当前的时间片的运行数量话就停止(如果只运行一次的话就马上调用停止,下次运行将从列表中移去,因为已经加入了TimeSlice.s_TimeSliceQueue集合所以会调用一次的)
                            if (timeSlice.Value.Count != 0 && ++timeSlice.Value.Adding >= timeSlice.Value.Count)
                            {
                                timeSlice.Value.Stop();
                            }
                            else
                            {
                                timeSlice.Value.NextTime = nowDateTime + timeSlice.Value.IntervalTime; // 计算下次调用的时间
                            }
                        }
                    }
                }

                if (bLoaded == true)
                {
                    OneServer.SetAllWorldSignal();
                }
            }

            // 向服务程序注册创建的新线程已结束
            OneServer.EndRegisterThread();
        }
예제 #2
0
        /// <summary>
        /// Timer的主要处理函数,用来计算是否需要处理的时候了
        /// </summary>
        private static void RunMobileAIThread()
        {
            // 向服务程序注册有新的线程在内部运行
            OneServer.BeginRegisterThread();

            LOGs.WriteLine(LogMessageType.MSG_INFO, "AI系统: 处理AI系统的主线程已启动!");

            //long l_iIndex = 0;
            bool     l_bLoaded     = false;
            DateTime l_nowDateTime = DateTime.Now;

            while (OneServer.Closing == false)
            {
                s_Signal.WaitOne(10, false);

                // 服务已经关闭则退出
                if (OneServer.Closing)
                {
                    break;
                }

                // 百分比输出显示
                if (s_IsDumpInfo)
                {
                    s_IsDumpInfo = false;
                    InternalDumpInfo();
                }

                // 先处理改变了优先级的时间片集合
                ProcessChangeQueue();

                l_bLoaded = false;

                //// 8种时间片
                //for ( l_iIndex = 0; l_iIndex < 8; l_iIndex++ )
                //{
                //    l_nowDateTime = DateTime.Now;

                //    // 如果小于下一次处理的时间片就跳出
                //    if ( l_nowDateTime < s_NextPriorities[l_iIndex] )
                //        break;

                //    // 设置下一次处理的时间片
                //    s_NextPriorities[l_iIndex] = l_nowDateTime + s_PriorityDelays[l_iIndex];

                //    foreach ( TimeSlice timeSlice in s_Timers[l_iIndex] )
                //    {
                //        // 如果当前时间片已经处理过,已不在先入先出的集合中,并且当前的时间大于下一次调用的时间
                //        if ( timeSlice.InQueued == false && l_nowDateTime > timeSlice.NextTime )
                //        {
                //            // 表示将当前的时间片已经加入先入先出集合中
                //            TimeSlice.JoinProcessQueue( timeSlice );

                //            l_bLoaded = true;

                //            // 如果运行次数大于等于当前的时间片的运行数量话就停止(如果只运行一次的话就马上调用停止,下次运行将从列表中移去,因为已经加入了TimeSlice.s_TimeSliceQueue集合所以会调用一次的)
                //            if ( timeSlice.Count != 0 && ( timeSlice.SetAdding( timeSlice.Adding + 1 ) >= timeSlice.Count ) )
                //                timeSlice.Stop();
                //            else
                //                timeSlice.SetNextTime( l_nowDateTime + timeSlice.IntervalTime ); // 计算下次调用的时间
                //        }
                //    }
                //}

                if (l_bLoaded)
                {
                    OneServer.SetAllWorldSignal();
                }
            }

            // 向服务程序注册创建的新线程已结束
            OneServer.EndRegisterThread();
        }
예제 #3
0
 public void BeginRegisterThreadTest()
 {
     OneServer.BeginRegisterThread();
     Assert.Inconclusive("无法验证不返回值的方法。");
 }