串行转并行

命令的传输形式有两种：

串行，并行

串行是指一条命令发送下去，得到了应答才继续发送下一条。

并行是指有几条命令，不管有没有收到应答，一律转下去，处理器把所有的命令存储起来，然后一条条处理。

串行的缺点是用户等待时间长，

并行则可能导致某些命令会被丢掉，但用户的命令很快就发送到处理器了。

 

所以串行的命令发送器做法就是：

有一个发送队列，有两个线程，一个接收线程，一个发送线程，一个事件。

发送一条命令，把事件waitone,阻塞，当接收线程接到回应或者超时了就Set一下事件，继续发送下一条。

 

并行的做法是去掉事件，只有发送队列里面有命令，就全部发送出去。

 

接收处理器

一个事件，三个线程，一个接收线程，一个发送线程，一个处理线程。

首先从接收队列里面取数据，如果取到数据，就委托给处理线程，这时候阻塞，处理完毕后调用发送线程发送处理的结果给命令发送器。继续从接收器处理下一条指令。

 

以下是设计的一个通讯器的发送和接收部分。

private void ContinuousReceive()
        {
            try
            {
                while (!m_cancellationTokenSource.IsCancellationRequested)
                {
                    int receivedBytes = m_socket.Receive(m_buffer);
                    if (receivedBytes > 0)
                    {
                        byte[] receive = new byte[receivedBytes];
                        Buffer.BlockCopy(m_buffer, 0, receive, 0, receivedBytes);
                        CommunicateData receiveData = new CommunicateData(receive);
                        m_lastReceivedDataTime = DateTime.Now;


                        m_onReceivedata(this, receiveData);
                        if (m_needSaveData)
                        {
                            m_receiveCollection.Add(receiveData);
                        }
                    }
                    else
                    {
                        Stop();
                        //Thread.Sleep(TimeSpan.FromSeconds(10));
                        Logger.Write(new LogEntry
                        {
                            Severity = System.Diagnostics.TraceEventType.Error,
                            Message = LogMessage.Message("Socket Receive 0 Bytes"),
                            Categories = new String[] { "Exception" }
                        });
                    }
                }
            }
            catch (Exception e)
            {
                Logger.Write(new LogEntry
                {
                    Severity = System.Diagnostics.TraceEventType.Error,
                    Message = LogMessage.Message(e),
                    Categories = new String[] { "Exception" }
                });

                lock (m_exceptionDeal)
                {
                    if (!m_hasDealException)
                    {
                        Stop();
                        m_hasDealException = true;
                        m_onException(this, e);
                    }
                }
            }
        }

private void ContinuousSend()
        {
            try
            {
                while (!m_cancellationTokenSource.IsCancellationRequested)
                {
                    CommunicateData sendData;
                    if (!m_isDsp)
                    {
                        sendData = m_sendCollection.Take(m_cancellationTokenSource.Token);
                    }
                    else
                    {
                        sendData = m_sendCollectionPr.Take();
                    }

                    //if (m_needAdjustCommunicatorId)
                    //{
                    //    LastSendCommunicateData = sendData;
                    //}

                    m_onSendData(this, sendData);
                    m_socket.Send(sendData.Data);
                    if (m_onMccTimeout != null)
                    {
                        m_onMccTimeout();
                    }

                    if (SendIntervalSecond != 0)
                    {
                        Thread.Sleep(TimeSpan.FromSeconds(SendIntervalSecond));
                    }
                }
            }
            catch (Exception e)
            {
                Logger.Write(new LogEntry
                {
                    Severity = System.Diagnostics.TraceEventType.Error,
                    Message = LogMessage.Message(e),
                    Categories = new String[] { "Exception" }
                });

                lock (m_exceptionDeal)
                {
                    if (!m_hasDealException)
                    {
                        Stop();
                        m_hasDealException = true;
                        m_onException(this, e);
                    }
                }
            }
        }

 

 

一些改进，比如某条命令需要插队，优先处理，那么就在处理的接受队列里面实现插队功能。

这个设计完全不考虑命令是什么形式的，各种业务需要根据自己的业务逻辑去实现一个命令的接口。

由于是有串转并，发送方有可能同时发几个命令，在接收方当成一个命令来处理，这就需要接收方根据命令的特征进行分包处理。