Esempio n. 1
0
        /// <summary>
        /// 清除数据
        /// </summary>
        public void Clear()
        {
            SpinLockEx.ReliableEnter(ref m_LockFlushAndPending);
            try
            {
                while (m_PendingBuffer.Count > 0)
                {
                    m_PendingBuffer.Dequeue().Release();
                }

                if (m_FlushBuffer.IsNull == false)
                {
                    m_FlushBuffer.Release();
                    m_FlushBuffer = SendBuffer.NullBuffer;
                }

                // 清空
                m_WaitSendSize = 0;
            }
            finally
            {
                m_LockFlushAndPending.Exit();
            }
        }
Esempio n. 2
0
        /// <summary>
        /// 发送缓存的数据
        /// </summary>
        /// <returns>是否成功处理缓存的发送</returns>
        internal bool Flush()
        {
            if (m_SendQueue.IsEmpty == true)
            {
                return(true);
            }

            if (Running == false)
            {
                return(false);
            }

            // 等待发送的数据累计过多,断开
            if (m_SendQueue.WaitSendSize >= SendCachedMaxSize)
            {
                // 需要注释
                Logs.Warn("NetState[{0}] Flush(...) - WaitSendSize[{1}] >= {2} warning (发送缓存的数据包过大)!", ToString(), m_SendQueue.WaitSendSize, SendCachedMaxSize);

                Dispose();

                return(false);
            }

            if (m_SendPackSize1Sec >= SendMaxSize1Sec)
            {
                DateTime nowDateTime = OneServer.NowTime;

                // 如果小于计算的时间,表示已经超过了数据流量,等待下一个时间
                if (nowDateTime < (m_SendTimeStart + s_TimeSpan1Sec))
                {
                    return(true);
                }
                else    // 如果已经超过计算的时间,开始重新计算时间与数据
                {
                    m_SendTimeStart    = nowDateTime;
                    m_SendPackSize1Sec = 0;
                }
            }

            SendBuffer sendBuffer = m_SendQueue.Dequeue();

            while (sendBuffer.IsNull == false)
            {
                MessageBlock messageBlock = m_Socket.GetNewSendMessageBlock();
                if (messageBlock == null)
                {
                    throw new ArgumentNullException("messageBlock", "NetState.Flush(...) - messageBlock == null error!");
                }

                if (sendBuffer.Length > messageBlock.Size)
                {
                    throw new ArgumentException("NetState.Flush(...) - sendBuffer.Length > messageBlock.Length error!", "sendBuffer");
                }

                Marshal.Copy(sendBuffer.Buffer, 0, messageBlock.WritePointer(), (int)sendBuffer.Length);

                messageBlock.WritePointer((int)sendBuffer.Length);

                // XG
                ++SanGuo.SanGuoMonitor.tcpMonitor.front.c13.runCount;
                SanGuo.SanGuoMonitor.tcpMonitor.front.c14.runCount += sendBuffer.Length;

                m_Socket.SendTo(messageBlock);

                // 释放数据
                sendBuffer.Release();

                // 累计发送的数据大小
                m_SendPackSize1Sec += sendBuffer.Length;

                // 已经超过了数据流量,就等待下一秒开始重新计算
                if (m_SendPackSize1Sec >= SendMaxSize1Sec)
                {
                    break;
                }

                // 需添加检测是否还有数据 否则以后就发不出去数据了(该问题解决)
                sendBuffer = m_SendQueue.Dequeue();
            }

            return(true);
        }