/// <summary>
        /// 初始化管理
        /// </summary>
        /// <param name="maxConnectionCount">允许的最大连接数</param>
        /// <param name="initConnectionResourceCount">启动时初始化多少个连接的资源</param>
        /// <param name="singleBufferMaxSize">每个 socket 读写缓存最大字节数, 默认为8k</param>
        /// <param name="sendTimeOut">socket 发送超时时长, 以毫秒为单位</param>
        /// <param name="receiveTimeOut">socket 接收超时时长, 以毫秒为单位</param>
        public virtual async Task InitAsync(int maxConnectionCount, int initConnectionResourceCount, ISocketBufferProcess bufferProcess, int singleBufferMaxSize = 8 * 1024
                                            , int sendTimeOut = 10000, int receiveTimeOut = 10000)
        {
            this.maxConnCount = maxConnectionCount;
            this.initConnectionResourceCount = initConnectionResourceCount;
            this.singleBufferMaxSize         = singleBufferMaxSize;
            this.sendTimeOut    = sendTimeOut;
            this.receiveTimeOut = receiveTimeOut;

            await Task.Run(() =>
            {
                this.semaphore = new Semaphore(this.maxConnCount, this.maxConnCount);
                //设置初始线程数为cpu核数*2
                this.connectedEntityList = new ConcurrentDictionary <int, IOCPSocket.SocketUserToken>(Environment.ProcessorCount * 2, this.maxConnCount);
                //读写分离, 每个socket连接需要2个SocketAsyncEventArgs.
                saePool = new SocketAsyncEventArgsPool(this.initConnectionResourceCount * 2, SendAndReceiveArgs_Completed, this.singleBufferMaxSize);

                this.entityPool = new ConcurrentStack <SocketUserToken>();

                Parallel.For(0, initConnectionResourceCount, i =>
                {
                    SocketUserToken token = new SocketUserToken(bufferProcess, singleBufferMaxSize);
                    token.ReceiveArgs     = saePool.Pop();
                    token.SendArgs        = saePool.Pop();
                    this.entityPool.Push(token);
                });
            });
        }
 /// <summary>
 /// 释放 token 资源, 将 token 放回池
 /// </summary>
 /// <param name="token">要释放的 token</param>
 protected virtual void FreeUserToken(SocketUserToken token)
 {
     if (token != null)
     {
         CloseSocket(token.CurrentSocket);
         token.Reset();
         entityPool.Push(token);
     }
 }
        /// <summary>
        /// 获取一个 userToken 资源
        /// </summary>
        /// <returns></returns>
        protected virtual SocketUserToken GetUserToken()
        {
            SocketUserToken result = null;

            if (!entityPool.TryPop(out result))
            {
                result             = new SocketUserToken(BufferProcess, singleBufferMaxSize);
                result.ReceiveArgs = saePool.Pop();
                result.SendArgs    = saePool.Pop();
            }

            return(result);
        }
        /// <summary>
        /// 执行 socket 连接成功时的处理
        /// </summary>
        /// <param name="s"></param>
        /// <returns>返回 userToken</returns>
        protected virtual SocketUserToken ToConnCompletedSuccess(Socket s)
        {
            SocketUserToken result = null;

            try
            {
                //等待3秒,如果有空余资源,接收连接,否则断开socket.
                if (semaphore.WaitOne(3000))
                {
                    result = GetUserToken();
                    result.CurrentSocket         = s;
                    result.Id                    = (int)s.Handle;
                    result.ReceiveArgs.UserToken = result;
                    result.SendArgs.UserToken    = result;

                    if (connectedEntityList.TryAdd(result.Id, result))
                    {
                        if (!result.CurrentSocket.ReceiveAsync(result.ReceiveArgs))
                        {
                            SendAndReceiveArgs_Completed(this, result.ReceiveArgs);
                        }

                        if (!result.CurrentSocket.SendAsync(result.SendArgs))
                        {
                            SendAndReceiveArgs_Completed(this, result.SendArgs);
                        }

                        //SocketError.Success 状态回传null, 表示没有异常
                        OnConnectedStatusChange(this, result.Id, true, null);
                    }
                    else
                    {
                        FreeUserToken(result);
                        semaphore.Release();
                    }
                }
                else
                {
                    CloseSocket(s);
                }
            }
            catch (Exception ex)
            {
                CloseSocket(s);
                OnError(this, ex);
            }

            return(result);
        }
        /// <summary>
        /// 从已连接集合中移除指定的 token
        /// </summary>
        /// <param name="token"></param>
        /// <returns></returns>
        protected virtual SocketUserToken RemoveUserToken(SocketUserToken token)
        {
            SocketUserToken result = null;

            if (token != null)
            {
                if (connectedEntityList.TryRemove(token.Id, out result))
                {
                    semaphore.Release();
                    OnConnectedStatusChange(this, token.Id, false, null);
                }
            }

            return(result);
        }
 /// <summary>
 /// 执行 socket 连接异常时的处理
 /// </summary>
 protected virtual void ToConnCompletedError(Socket s, SocketError error, SocketUserToken token)
 {
     try
     {
         FreeUserToken(RemoveUserToken(token));
     }
     catch (Exception ex)
     {
         OnError(this, ex);
     }
     finally
     {
         CloseSocket(s);
     }
 }