智能预判 （二：最初的布局）

不太会画图，先简单看下 程序流程，他比 其他 服务器 多了 一个 单独的 线程 内部数据库 物理运算，也就是  他的运算 不需要 客户端  时时给信息。

下面是 片段代码。

            var bootstrap = BootstrapFactory.CreateBootstrap();

            if (!bootstrap.Initialize())
            {
                Console.WriteLine("无法初始化");
                Console.ReadKey();
                return;
            }

            var result = bootstrap.Start();

            Console.WriteLine("服务器启动: {0}!", result);

            if (result == StartResult.Failed)
            {
                Console.WriteLine("无法启动");
                Console.ReadKey();
                return;
            }

            Console.WriteLine("线程池开启！");

            ThreadPoolMain.OnStartThreadPool();

　　

        public static void OnStartThreadPool()
        {
            cs = "server=127.0.0.1;database=playgame;user=sa;pwd=zzjzzj888;pooling=true;min pool size=10;max pool size=10000";
            OnSqlHelper = new SqlHelper(cs);

            //新建ManualResetEvent对象并且初始化为无信号状态
            ManualResetEvent eventX = new ManualResetEvent(false);
            ThreadPool.SetMaxThreads(12, 12); //线程池  
            ThreadQueue Queue = new ThreadQueue();


            while (OnReadSql()>0)
            {
                Console.WriteLine("结束并修改数据库!!");
                Queue.QueueWorkItem(eventX, taskcount);//分配任务
                eventX = new ManualResetEvent(false);  
            } 
        }

        static int taskcount;
        //读取数据库，如果没符合条件 等待后继续读取
        static int OnReadSql()
        {
            // 读取数据库数据，拿到最新的 当前时间点 之内  的数据。
            //排序这列数据。
            taskcount = sqls();//任务数量 
            if (taskcount == 0)
            {
                Thread.Sleep(11);//如果没有数据，则2秒钟后继续寻找
                OnReadSql();
            }
            return taskcount;
        }

        public bool QueueWorkItem(ManualResetEvent eventX, int task)
        {
            Console.WriteLine("主线程运行开始");
            Thread.Sleep(1000);
            ThreadProcClass t = new ThreadProcClass(task, eventX);
            for (int i = 0; i < task; i++)
            {
                JsonData json = new JsonData();
                json["name"] = "zzj" + i;
                json["message"] = "ok" + i;
                ThreadPool.QueueUserWorkItem(new WaitCallback(t.ThreadProc), new SomeState(json));
            }
            //等待事件的完成，即线程调用ManualResetEvent.Set()方法
            //eventX.WaitOne  阻止当前线程，直到当前 WaitHandle 收到信号为止。 
            eventX.WaitOne(Timeout.Infinite, true);
            return true;
        }

        public ThreadProcClass(int count, ManualResetEvent mre)
        {
            iMaxCount = count;
            eventX = mre;
        }

        public static int iCount = 0;
        public static int iMaxCount = 0;
        public ManualResetEvent eventX;
        public void ThreadProc(object i)
        {
            Console.WriteLine("Thread " + ((SomeState)i).json.ToJson());
            Thread.Sleep(1111);
            //Interlocked.Increment()操作是一个原子操作，作用是:iCount++ 具体请看下面说明 
            //原子操作，就是不能被更高等级中断抢夺优先的操作。你既然提这个问题，我就说深一点。
            //由于操作系统大部分时间处于开中断状态，
            //所以，一个程序在执行的时候可能被优先级更高的线程中断。
            //而有些操作是不能被中断的，不然会出现无法还原的后果，这时候，这些操作就需要原子操作。
            //就是不能被中断的操作。
            Interlocked.Increment(ref iCount);
            if (iCount == iMaxCount)
            {
                //   Console.WriteLine("最后一个子线程发出结束信号!");
                //将事件状态设置为终止状态，允许一个或多个等待线程继续。
                iCount = 0;
                eventX.Set();
            }
        }