System.Net.Sockets.NetworkStream이 Thread-safe할까?

socket 관련 thread-safe의 마지막 글입니다. ^^

System.Net.Sockets.Socket이 Thread-safe할까?
; https://www.sysnet.pe.kr/2/0/1469

Win32 socket이 Thread-safe할까?
; https://www.sysnet.pe.kr/2/0/1473

이번에는 Socket I/O를 Stream으로 감싼 System.Net.Sockets.NetworkStream 차례입니다. 아래의 문서에 보면,

NetworkStream Class
; https://docs.microsoft.com/en-us/dotnet/api/system.net.sockets.networkstream

NetworkStream 역시 일반 BCL과 마찬가지의 thread-safety 정책이 걸려 있습니다.



그래서 지난번 글과 동일하게 테스트를 해보았는데,

static void Main(string[] args)
{
    Thread.Sleep(2000);

    string body = string.Empty;
    StringBuilder sb = new StringBuilder();

    Array.ForEach(Enumerable.Range(0, 10).ToArray(), (elem) => body += elem.ToString());
    for (int i = 0; i < 10000; i++)
    {
        sb.Append(body);
    }

    body = sb.ToString();

    int loopCount = 10000;
    int dot = (loopCount / (80 * 25));

    List<CommonPacket> packets = new List<CommonPacket>();

    using (TcpClient socket = new TcpClient("192.168.0.6", 11200))
    {
        // IPAddress target = IPAddress.Loopback; 
        IPAddress target = IPAddress.Parse("192.168.0.6");
        EndPoint serverEP = new IPEndPoint(target, 11200);

        NetworkStream ns = socket.GetStream();
        int instanceId = 0;

        byte[] instanceIdBuf = BitConverter.GetBytes(instanceId);
        ns.Write(instanceIdBuf, 0, 4);

        for (int i = 0; i < loopCount; i++)
        {
            CommonPacket packet = new CommonPacket(i);
            packet.AddData(body);

            packets.Add(packet);
        }

        List<Thread> threads = new List<Thread>();
        ThreadParam threadParam = new ThreadParam();
        threadParam.Packets = packets;
        threadParam.NetStream = ns;
        threadParam.Dot = dot;

        for (int i = 0; i < 20; i++)
        {
            Thread aThread = new Thread(sendBufferThread);
            aThread.IsBackground = true;
            aThread.Start(threadParam);

            threads.Add(aThread);
        }

        foreach (var item in threads)
        {
            item.Join();
        }

        socket.Close();
        Console.WriteLine("TCP Client socket: Closed");
        Console.WriteLine(loopCount + " times: data sent");
        Console.WriteLine((body.Length / 1024) + "KB / packet");

        Console.WriteLine();
        Console.WriteLine();

        Console.WriteLine("Press any key to exit");
        Console.ReadLine();
    }
}

private static void sendBufferThread(object obj)
{
    ThreadParam threadParam = (ThreadParam)obj;

    while (true)
    {
        CommonPacket packet = null;

        lock (threadParam.Packets)
        {
            if (threadParam.Packets.Count == 0)
            {
                break;
            }

            packet = threadParam.Packets[0];
            threadParam.Packets.RemoveAt(0);
            threadParam.Sent++;

            if (threadParam.Sent % threadParam.Dot == 0)
            {
                Console.Write(".");
            }
        }

        byte[] dataBuf = packet.GetBuffer();
        MustSendBuffer(threadParam.NetStream, dataBuf, dataBuf.Length);
    }
}

private static bool MustSendBuffer(NetworkStream ns, byte[] dataBuf, int mustSend)
{
    ns.Write(dataBuf, 0, mustSend);
    return true;
}

결과는 thread-safe했습니다. 이상하군요. 그런대로 충돌이 날 만한데요. 이에 대해서는 NetworkStream.Write 메서드를 .NET Reflector를 통해 보면 짐작할 수 있습니다.

public override void Write(byte[] buffer, int offset, int size)
{
    bool canWrite = this.CanWrite;
    if (this.m_CleanedUp)
    {
        throw new ObjectDisposedException(base.GetType().FullName);
    }
    if (!canWrite)
    {
        throw new InvalidOperationException(SR.GetString("net_readonlystream"));
    }
    if (buffer == null)
    {
        throw new ArgumentNullException("buffer");
    }
    if ((offset < 0) || (offset > buffer.Length))
    {
        throw new ArgumentOutOfRangeException("offset");
    }
    if ((size < 0) || (size > (buffer.Length - offset)))
    {
        throw new ArgumentOutOfRangeException("size");
    }
    Socket streamSocket = this.m_StreamSocket;
    if (streamSocket == null)
    {
        throw new IOException(SR.GetString("net_io_writefailure", new object[] { SR.GetString("net_io_connectionclosed") }));
    }
    try
    {
        streamSocket.Send(buffer, offset, size, SocketFlags.None);
    }
    catch (Exception exception)
    {
        if (((exception is ThreadAbortException) || (exception is StackOverflowException)) || (exception is OutOfMemoryException))
        {
            throw;
        }
        throw new IOException(SR.GetString("net_io_writefailure", new object[] { exception.Message }), exception);
    }
}

보시는 바와 같이 Write(및 Read) 메서드 안에서 인스턴스 멤버에 대한 조작을 하는 코드가 없습니다. 하부 단의 "Socket streamSocket" 멤버는 Socket 자체가 thread-safe하기 때문에 상관없고!

물론 NetworkStream 타입의 멤버가 thread-safe하지 않다고 되어 있으므로 향후 내부적으로 인스턴스 멤버를 조작하는 코드가 추가되는 경우 오동작을 할 여지가 있습니다. 따라서, 성능에 크게 영향이 없다면 NetworkStream을 사용하는 경우에는 lock을 적절하게 걸어주는 것이 권장됩니다.

(첨부파일은 위의 동작을 테스트한 코드를 담고 있습니다.)

---

[이 글에 대해서 여러분들과 의견을 공유하고 싶습니다. 틀리거나 미흡한 부분 또는 의문 사항이 있으시면 언제든 댓글 남겨주십시오.]

[최초 등록일: 1/29/2014]
[최종 수정일: 7/17/2021]


이 저작물은 크리에이티브 커먼즈 코리아 저작자표시-비영리-변경금지 2.0 대한민국 라이센스에 따라 이용하실 수 있습니다.

by SeongTae Jeong, mailto:techsharer at outlook.com