螺纹Socket.Send（）

Question

I have 2 threads running simultaneously and each is writing to the socket.Send() stream,

   While (soc.Connected)
        {


                byte[] byData = new byte[2];
                byData = System.Text.Encoding.ASCII.GetBytes("A");
                soc.Send(BitConverter.GetBytes(byData.Length));
                soc.Send(byData);


        }

The other thread uses the exact same code, except it's sending "1" instead of "A".

How will the data at the other end look like? Will it be either a stream of AAAAAAAA or 111111111s or randomly mixed like A1A1111AAAA1 ?

Should I avoid this way of sending entirely and block the sending until the other thread finishes?

Answer 1

Should I avoid this way of sending entirely and block the sending until the other thread finishes?

Yes and no, you should avoid this entirely but it is not necessary to block sending till the other thread finishes.

What you could do is have a 3rd thread who's responsibility is to send data and your two threads who need to send data put their data on to a thread safe queue. Then the sending thread would dequeue the work to be done and send it out on the wire.

const int MAX_QUEUE_LENGTH = 10;
private BlockingCollection<MyMessageContainer> messageQueue = new BlockingCollection<MyMessageContainer>(new ConcurrentQueue<MyMessageContainer>(), MAX_QUEUE_LENGTH);

void ProcessMessages()
{
    foreach (var message in messageQueue.GetConsumingEnumerable())
    {
        if(soc.Connected == false)
            break;

        soc.Send(message.ToPaylod());
    }
}

void GenerateMessageOne()
{
    while(true)
    {
        messageQueue.Add(new MyMessageContainer("A"));
    }
}

void GenerateMessageTwo()
{
    while(true)
    {
        messageQueue.Add(new MyMessageContainer("1"));
    }
}


class MyMessageContainer
{
     public MyMessageContainer(string message)
     {
          _message = message;
     }

     private string _message;

     public byte[] ToPayload()
     {
         var lengthBytes = BitConverter.GetBytes(byData.Length);
         return lengthBytes.Concat(() => System.Text.Encoding.ASCII.GetBytes(_message)).ToArray();
     }
}

The above code will let both threads queue work at the same time without blocking till the queue reaches a length of MAX_QUEUE_LENGTH , once there calling messageQueue.Add( will now start blocking till the sending thread has had a chance to clear up some room, once room has been made it will unblock one of the functions and let it continue.

Answer 2

If you want randomly-sequenced output, the easiest solution is to simply put a lock around the line that actually writes to the socket. I would also recommend adding a call to Thread.Sleep for fairness, though that is somewhat optional.

While (soc.Connected)
{
    byte[] byData = new byte[2];
    byData = System.Text.Encoding.ASCII.GetBytes("A");
    lock(soc) 
    {
        soc.Send(BitConverter.GetBytes(byData.Length));
        soc.Send(byData);
    }
    Thread.Sleep(0);
}