C# 如何防止线程的两个副本复制方法和变量

目前，我有两台客户端计算机将Kinect关节数据发送到服务器计算机，但有两个单独的线程运行侦听器，因此（

字符串

）变量的两个单独副本正在读取数据。有没有办法设置两个不同的变量，从两台不同的客户端计算机读取数据，而不是创建一个重复的线程

public class AsynchIOServer
{
    static void Listeners(object state)
    {
        TcpListener listener = state as TcpListener;
        using (Socket socketForClient = listener.AcceptSocket())
        {
            if (socketForClient.Connected)
            {
                Console.WriteLine("Client:" + socketForClient.RemoteEndPoint + " now connected to server.");
                using (NetworkStream networkStream = new NetworkStream(socketForClient))
                using (System.IO.StreamWriter streamWriter = new System.IO.StreamWriter(networkStream))
                using (System.IO.StreamReader streamReader = new System.IO.StreamReader(networkStream))
                {
                    try
                    {
                        while (true)
                        {
                            string theString = streamReader.ReadLine();
                            if (string.IsNullOrEmpty(theString) == false)
                            {
                                Console.WriteLine("Message recieved by  " + theString);
                                var result = theString.Split(',');
                            }
                        }

                    }
                    catch (Exception ex)
                    {
                        Console.WriteLine("Error: " + ex.Message);
                    }
                }
            }
        }
        Console.WriteLine("Press any key to exit from server program");
        Console.ReadKey();
    }

    public static void Main()
    {

        TcpListener[] listeners =
        {
            new TcpListener(15), new TcpListener(10)
        };


        Console.WriteLine("***********This is Server program***********");
        Console.WriteLine("How many clients are going to connect to this server?:");
        int numberOfClientsYouNeedToConnect =int.Parse( Console.ReadLine());


        foreach (TcpListener listener in listeners)
        {
            listener.Start();
            for (int i = 0; i < numberOfClientsYouNeedToConnect; i++)
            {
                Thread newThread = new Thread(new ParameterizedThreadStart(Listeners));
                newThread.Start(listener);
            }
        }

    }
} 

公共类异步服务器
{
静态void侦听器（对象状态）
{
TcpListener listener=状态为TcpListener；
使用（Socket socketForClient=listener.AcceptSocket（））
{
if（socketForClient.Connected）
{
WriteLine（“客户端：+socketForClient.RemoteEndPoint+“现在已连接到服务器”）；
使用（NetworkStream NetworkStream=新的NetworkStream（socketForClient））
使用（System.IO.StreamWriter StreamWriter=new System.IO.StreamWriter（networkStream））
使用（System.IO.StreamReader StreamReader=new System.IO.StreamReader（networkStream））
{
尝试
{
while（true）
{
字符串字符串=streamReader.ReadLine（）；
if（string.IsNullOrEmpty（theString）==false）
{
Console.WriteLine（“由“+字符串接收的消息”）；
var result=string.Split（'，'）；
}
}
}
捕获（例外情况除外）
{
Console.WriteLine（“错误：+ex.Message”）；
}
}
}
}
Console.WriteLine（“按任意键退出服务器程序”）；
Console.ReadKey（）；
}
公共静态void Main（）
{
TcpListener[]侦听器=
{
新TcpListener（15），新TcpListener（10）
};
Console.WriteLine（“*************这是服务器程序**********”）；
WriteLine（“有多少客户端将连接到此服务器？：”；
int numberOfClientsYouNeedToConnect=int.Parse（Console.ReadLine（））；
foreach（侦听器中的TcpListener侦听器）
{
listener.Start（）；
for（int i=0；i

使用类似下面代码的状态对象：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Net.Sockets;
using System.Threading;
using System.IO;

namespace ConsoleApplication1
{
    public class AsynchIOServer
    {
        public class State
        {
            public TcpListener listener { get; set; }
            public StreamReader streamReader { get; set; }
            public StreamWriter streamWriter { get; set; }
            public NetworkStream networkStream { get; set; }
            public Socket socketForClient { get; set; }
        }
        static void Listeners(object obj)
        {
            State state = obj as State;
            using (state.socketForClient = state.listener.AcceptSocket())
            {
                if (state.socketForClient.Connected)
                {
                    Console.WriteLine("Client:" + state.socketForClient.RemoteEndPoint + " now connected to server.");
                    using (state.networkStream = new NetworkStream(state.socketForClient))
                    using (state.streamWriter = new System.IO.StreamWriter(state.networkStream))
                    using (state.streamReader = new System.IO.StreamReader(state.networkStream))
                    {
                        try
                        {
                            while (true)
                            {
                                string theString = state.streamReader.ReadLine();
                                if (string.IsNullOrEmpty(theString) == false)
                                {
                                    Console.WriteLine("Message recieved by  " + theString);
                                    var result = theString.Split(',');
                                }
                            }

                        }
                        catch (Exception ex)
                        {
                            Console.WriteLine("Error: " + ex.Message);
                        }
                    }
                }
            }
            Console.WriteLine("Press any key to exit from server program");
            Console.ReadKey();
        }

        public static void Main()
        {
            State[] states = new State[] {
                new State() { listener = new TcpListener(15)},
                new State() { listener = new TcpListener(10)}
            };



            Console.WriteLine("***********This is Server program***********");
            Console.WriteLine("How many clients are going to connect to this server?:");
            int numberOfClientsYouNeedToConnect = int.Parse(Console.ReadLine());


            foreach (State state in states)
            {
                state.listener.Start();
                for (int i = 0; i < numberOfClientsYouNeedToConnect; i++)
                {
                    Thread newThread = new Thread(new ParameterizedThreadStart(Listeners));
                    newThread.Start(state);
                }
            }

        }
    } 

}

使用系统；
使用System.Collections.Generic；
使用System.Linq；
使用系统文本；
使用System.Net.Sockets；
使用系统线程；
使用System.IO；
命名空间控制台应用程序1
{
公共类异步服务器
{
公共阶级国家
{
公共TcpListener侦听器{get；set；}
公共StreamReader StreamReader{get；set；}
公共StreamWriter StreamWriter{get；set；}
公共网络流网络流{get；set；}
公共套接字socketForClient{get；set；}
}
静态无效侦听器（对象obj）
{
状态=obj作为状态；
使用（state.socketForClient=state.listener.AcceptSocket（））
{
if（state.socketForClient.Connected）
{
WriteLine（“客户端：+state.socketForClient.RemoteEndPoint+“现在已连接到服务器”）；
使用（state.networkStream=newnetworkstream（state.socketForClient））
使用（state.streamWriter=new System.IO.streamWriter（state.networkStream））
使用（state.streamReader=new System.IO.streamReader（state.networkStream））
{
尝试
{
while（true）
{
字符串字符串=state.streamReader.ReadLine（）；
if（string.IsNullOrEmpty（theString）==false）
{
Console.WriteLine（“由“+字符串接收的消息”）；
var result=string.Split（'，'）；
}
}
}
捕获（例外情况除外）
{
Console.WriteLine（“错误：+ex.Message”）；
}
}
}
}
Console.WriteLine（“按任意键退出服务器程序”）；
Console.ReadKey（）；
}
公共静态void Main（）
{
状态[]状态=新状态[]{
新状态（）{listener=new TcpListener（15）}，
新状态（）{listener=new TcpListener（10）}
};
Console.WriteLine（“*************这是服务器程序**********”）；
WriteLine（“有多少客户端将连接到此服务器？：”；
int numberOfClientsYouNeedToConnect=int.Parse（Console.ReadLine（））；
foreach（州中的州）
{
state.listener.Start（）；
for（int i=0；i

我在运行程序时不断收到一个错误，说

状态

为空。我做了一个小更改来初始化侦听器。现在它说

状态

和

socketForClient

也为空，两个客户端都将数据发送到服务器a