private static int _maxConnectCount = 20000;

        private static Socket _socketListen;

        private const int _bufferSize = 4096;

        private static double _nowUploadBit, _nowDownloadBit;

        private static Semaphore _sea;

        private static UserTokenPool _userTokenPool;

        private static void Init()

        {

            _sea = new Semaphore(_maxConnectCount, _maxConnectCount);

            _userTokenPool = new UserTokenPool(_maxConnectCount);

            UserToken userToken;

            for (int i = 0; i < _maxConnectCount; i++)

            {

                userToken = new UserToken(_bufferSize);

                userToken.ReceiveEventArgs.Completed += new EventHandler<SocketAsyncEventArgs>(OnReceiveCompleted);

                _userTokenPool.Enqueue(userToken);

            }

        }

        //启动侦听

        public static bool Start()

        {

            try

            {

                Init();

                _socketListen = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);

                IPEndPoint endpoint = new IPEndPoint(IPAddress.Any, 80);

                _socketListen.Bind(endpoint);

                _socketListen.Listen(Int32.MaxValue);

                _userTokenPool.StartCheckTimeOut(CheckTimeOutSec);

                StartAccept(null);

                return true;

            }

            catch { }

            return false;

        }

        //接收连接

        private static void StartAccept(SocketAsyncEventArgs async)

        {

            try

            {

                if (async == null)

                {

                    async = new SocketAsyncEventArgs();

                    async.Completed += new EventHandler<SocketAsyncEventArgs>(OnAcceptCompleted);

                }

                else

                {

                    async.AcceptSocket = null;

                }

                //这里设的并发2万，达到2万才会阻塞

                _sea.WaitOne();

                if (!_socketListen.AcceptAsync(async))

                    ProcessAccept(async);

            }

            catch (Exception ex)

            {

                WriteSocketErr("StartAccept：" + ex.Message + "，行号" + ex.StackTrace);

            }

        }

        private static void OnAcceptCompleted(object sender, SocketAsyncEventArgs e)

        {

            ProcessAccept(e);

        }

        private static void OnReceiveCompleted(object sender, SocketAsyncEventArgs e)

        {

            ProcessReceive(e);

        }

        private static void OnSendCompleted(object sender, SocketAsyncEventArgs e)

        {

            if (e == null)

                return;

            UserToken userToken = e.UserToken as UserToken;

            if (!userToken.IsKeepAlive)

                CloseClientSocket(userToken);

            e.BufferList.Clear();

            e.BufferList = null;

            e.Completed -= new EventHandler<SocketAsyncEventArgs>(OnSendCompleted);

            e.Dispose();

            e = null;

        }

        private static void ProcessAccept(SocketAsyncEventArgs e)

        {

            try

            {

                SocketError err = e.SocketError;

                Socket sock = e.AcceptSocket;

                e.AcceptSocket = null;

                StartAccept(e);

                if (err != SocketError.Success)

                    return;

                UserToken userToken = _userTokenPool.Dequeue();

                userToken.Socket = sock;

                string ip = sock.RemoteEndPoint.ToString();

                ip = ip.Remove(ip.IndexOf(":"));

                userToken.IP = ip;

                if (sock.Connected)

                {

                    if (!sock.ReceiveAsync(userToken.ReceiveEventArgs))

                        ProcessReceive(userToken.ReceiveEventArgs);

                }

                else

                    CloseClientSocket(userToken);

            }

            catch (SocketException ex)

            {

                WriteSocketErr("ProcessAccept：" + ex.Message + "\r\n行号" + ex.StackTrace);

            }

        }

        private static void ProcessReceive(SocketAsyncEventArgs e)

        {

            try

            {

                UserToken userToken = e.UserToken as UserToken;

                if (userToken.ReceiveEventArgs.BytesTransferred > 0 && userToken.ReceiveEventArgs.SocketError == SocketError.Success)

                {

                    _nowDownloadBit += userToken.ReceiveEventArgs.BytesTransferred;

                    string header = Encoding.Default.GetString(e.Buffer, e.Offset, e.BytesTransferred);

                   //处理http请求

                    ProcessHttp(userToken, header);

                    if (userToken.Socket != null && userToken.IsKeepAlive && !userToken.Socket.ReceiveAsync(userToken.ReceiveEventArgs))

                        ProcessReceive(userToken.ReceiveEventArgs);

                }

                else

                    CloseClientSocket(userToken);

            }

            catch (Exception ex)

            {

                WriteSocketErr("ProcessReceive：" + ex.Message + "\r\n行号" + ex.StackTrace);

            }

        }

        //处理http请求

        private static void ProcessHttp(userToken, header)

        {

            //

            //处理数据......

            //

            //处理完后发送给客户端

            SendAsync(userToken, buffers);

        }

        private static void SendAsync(UserToken userToken, params byte[][] buffers)

        {

            SocketAsyncEventArgs async = new SocketAsyncEventArgs();

            try

            {

                List<ArraySegment<byte>> list = new List<ArraySegment<byte>>(buffers.Length);

                ArraySegment<byte> ary;

                foreach (var item in buffers)

                {

                    ary = new ArraySegment<byte>(item);

                    list.Add(ary);

                    _nowUploadBit += item.Length;

                }

                async.Completed += new EventHandler<SocketAsyncEventArgs>(OnSendCompleted);

                async.RemoteEndPoint = userToken.Socket.RemoteEndPoint;

                async.BufferList = list;

                async.UserToken = userToken;

                if (!userToken.Socket.SendAsync(async))

                    OnSendCompleted(null, async);

            }

            catch (Exception ex)

            {

                WriteSocketErr("SendAsync：" + ex.Message + "行号：" + ex.StackTrace);

                CloseClientSocket(userToken);

                OnSendCompleted(null, async);

            }

        }

        //关闭连接

        public static void CloseClientSocket(UserToken userToken)

        {

            if (userToken.Socket == null)

                return;

            try

            {

                userToken.Socket.Shutdown(SocketShutdown.Both);

            }

            catch (SocketException ex)

            {

                WriteSocketErr("Shutdown：" + ex.Message);

            }

            try

            {

                userToken.Socket.Close();

            }

            catch (SocketException ex)

            {

                WriteSocketErr("Close：" + ex.Message);

            }

            userToken.Socket = null;

            _userTokenPool.Enqueue(userToken);

            _sea.Release();

        }

        //写入错误文件

        private static void WriteSocketErr(string errMsg)

        {

            lock (locker)

            {

                File.AppendAllText(errFilePath, string.Format("{0} {1}{2}", DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"),

                    errMsg, Environment.NewLine), Encoding.UTF8);

            }

        }