我有一个关于Threads的问题，我得到了一个多线程TCP accplication，它与多个客户端有连接。线程的操作需要很长时间。 （也许一分钟左右）。如果只有一个线程运行，我应该如何让我的Sleeps让所有线程都有相同的时间而不会产生延迟？
while(CanDoSomething)
{
DoIt(); //Can take all from a few seconds to a few minutes
Thread.Sleep(100);
}
这是睡眠的最佳方法吗？或者我应该给它一个更长的睡眠时间？其他线程只能获得100毫秒还是给它们时间开始然后芬兰语？ Becouse我有一种感觉，一个线程比其他线程更快地完成工作......我还能做些什么来确保它们以相同的优先级完成工作吗？
编辑，更多代码：
private void ListenForClients()
{
try
{
this.tcpListener.Start();
while (true)
{
TcpClient client = this.tcpListener.AcceptTcpClient();
Connection c = new Connection(this.parent);
connectionCollection.Add(c);
Thread clientThread = new Thread(new ParameterizedThreadStart(c.HandleClientComm));
threadCollection.Add(clientThread);
clientThread.Start(client);
}
}
catch (Exception e)
{
}
}
public Connection()
{
this.todo = new ArrayList();
todoT = new Thread(handleToDo);
todoT.Start();
}
public void HandleClientComm(object client)
{
try
{
TcpClient server = (TcpClient)client;
NetworkStream ns = server.GetStream();
byte[] data = new byte[1024];
string input, stringData;
online = true;
DateTime lastTime = DateTime.Now;
while (true && this.online)
{
try
{
if (lastTime.AddMinutes(2) < DateTime.Now)
break;
data = new byte[1024];
if (ns.DataAvailable && ns.CanRead)
{
int recv = ns.Read(data, 0, data.Length);
if (recv > 0)
{
lastTime = DateTime.Now;
if ((byte)data[recv - 1] == (byte)255)
{
int cnt = -1;
for (int i = 0; i < recv; i++)
{
if (data[i] == (byte)254)
{
cnt = i;
break;
}
}
int nr = recv - cnt - 2;
byte[] tmp = new byte[nr];
for (int i = 0; i < nr; i++)
{
tmp[i] = data[cnt + i + 1];
}
string crc = Encoding.UTF8.GetString(tmp);
stringData = Encoding.UTF8.GetString(data, 0, cnt);
MsgStruct msgs = new MsgStruct(stringData);
msgs.setCrc(crc);
Thread.Sleep(200);
addTodo(msgs);
if (msgs.getMsg()[0] == 'T' && this.type == 1)
this.parent.cStructHandler.sendAck(msgs, this.ID);
Console.WriteLine(todo.Count);
}
}
}
if (parent.cStructHandler.gotMsg(this.ID))
{
MsgStruct tmpCs = parent.cStructHandler.getNextMsg(this.ID);
if (tmpCs.getMsg().Length != 0 && ns.CanWrite)
{
byte[] ba = Encoding.UTF8.GetBytes(tmpCs.getMsg());
if (tmpCs.getCrc() == "")
{
ulong tmp = CRC.calc_crc(ba, ba.Length);
tmpCs.setCrc(tmp.ToString("X"));
}
if (tmpCs.canSendByTimeout())
{
string crcStr = "?" + tmpCs.getCrc() + "?";
byte[] bb = Encoding.UTF8.GetBytes(crcStr);
crcStr = Encoding.UTF8.GetString(bb);
byte[] fullMsg = new byte[ba.Length + bb.Length];
bb[0] = 254;
bb[bb.Length - 1] = 255;
ba.CopyTo(fullMsg, 0);
bb.CopyTo(fullMsg, ba.Length);
string s = System.Text.UTF8Encoding.ASCII.GetString(fullMsg);
ns.Write(fullMsg, 0, fullMsg.Length);
Thread.Sleep(200);
if (!tmpCs.isAckNeeded())
parent.cStructHandler.removeNextMsg(this.ID);
}
}
}
Thread.Sleep(100);
}
catch (Exception e)
{
break;
}
}
ns.Close();
server.Close();
dead = true;
}
catch (Exception e)
{
dead = true;
}
}
public void handleToDo()
{
try
{
int cnt = 0;
while (true)
{
if (todo.Count > 0)
{
//SWITCH CASE FOR DIFFERENT MESSAGE TYPES, DOING TASKS DEPENDING ON WHAT ONES...
Thread.Sleep(100);
}
else
{
if (dead)
{
todoT.Abort();
todoT = null;
break;
}
}
Thread.Sleep(200);
}
}
}
如果不清楚，请提问。
/尼克
答案 0 :(得分：2)
应该有一个集中的地方，任务生产者可以在其中存储新任务，以及任务消费者从哪里执行任务来处理它们。如果在消费者开始工作之前生成所有任务，问题就会更简单一些。您的工作线程是任务使用者。任务通常用一个对象表示，该对象包含完成任务所需的所有相关数据。工作线程不应该具有任何形式的睡眠，因为哪个线程更快以及完成了多少任务并不重要。只要有要执行的任务，线程就会在循环中使用任务。这种消费受到一些lock的保护。
编辑：我建议重构代码，以便只有一个线程以异步方式（BeginRead或ReadAsync）完成所有读取操作。代码将开始在每个套接字上读取，并等待某个套接字接收数据或关闭。如果收到套接字的数据且数据已完成，则生成新任务。您必须缓冲不完整的数据并阅读更多数据，直到数据完成。生成任务时，一个任务使用者最终应该接收任务，处理它并将结果发送到相应的套接字。因此，套接字从一个线程中读取并写入多个线程中。为了防止某些竞争条件，如果为其生成了未完成的未完成任务，则主读取器线程不得为特定套接字读取更多数据。任务完成后，主线程可能会开始读取更多数据。
我没有覆盖所有角落，因为那会产生一堵文字墙。也许有一个图书馆为你做所有的沟通，但我不知道。
答案 1 :(得分：2)
您的操作系统有一个调度程序。它已经在努力为每个线程提供相同的时间，并且更好地了解线程何时等待某些事情（因此只会浪费时间）。
我不确定你的问题是什么，但我确信这不是解决方案。有很多非常的实际代码案例，其中Sleep()很有用（我说“真实代码”，因为还有一些其他情况可以帮助调查和测试代码，而不是生产）。无论如何，这些极少数案例中的大多数已经存在于库代码中。他们都不需要使用高于10的值进行调用，而使用高于0的值进行调用时很少。
这不是其中之一。
答案 2 :(得分：1)
你不应该像这样使用任何Sleeps和while循环。即使使用while循环，在您的情况下也不会使用Sleep。
如果不了解您的要求，我建议您研究计时器。