c#增加并发任务执行之间的延迟

我有以下任务将一些数据发送到TCP套接字：

var tasks = new List<Task>();

foreach(int patient in patients)
{
    //tasks.Add(Work(patient));
    tasks.Add(Task.Factory.StartNew(() =>
    {
        var message = BuildCommand();
        var bytes = Socket.StartClient(message);

        var bits = new BitArray(bytes);
        var stringBytes = ToBitString(bits);

        SetResultsText(stringBytes + Environment.NewLine);

    }, TaskCreationOptions.LongRunning));
}

await Task.WhenAll(tasks.ToArray());

var tasks=newlist（）；
foreach（患者中的int患者）
{
//任务。添加（工作（患者））；
tasks.Add（Task.Factory.StartNew（（）=>
{
var message=BuildCommand（）；
var bytes=Socket.StartClient（消息）；
变量位=新的位数组（字节）；
var stringBytes=ToBitString（位）；
SetResultsText（stringBytes+Environment.NewLine）；
}，TaskCreationOptions.longrung））；
}
等待Task.WhenAll（tasks.ToArray（））；

我想要的是在每个任务之间增加一个大约200ms的延迟，这样它们就不会完全同时运行，因为我已经看到一些包在套接字上丢失了，所以我希望每个调用都延迟一点，以避免这个问题

我尝试了

Task.Delay

和

Thread.Sleep

，似乎任务仍在同时执行

object LockObject { get; set; }

public void Init() {
    LockObject = new object();
}

...YourMethod() {
    lock ( LockObject ) {
        ...YourTask
    }
}

调用YourMethod（）将一步一步地完成

LockObject将被锁定，直到您的任务完成，然后，它将调用您调用的另一个methodcall

您不需要为每个任务添加200ms

调用YourMethod（）将一步一步地完成

LockObject将被锁定，直到您的任务完成，然后，它将调用您调用的另一个methodcall

---

您不需要为每个任务添加200ms。

如果您无论如何都不想同时运行这些任务，并且假设有理由不只是同步运行代码来删除整个任务，那么在单个任务中按顺序执行所有操作可能会更简单

var task = Task.Factory.StartNew(() =>
{
    foreach(int patient in patients)
    {
        var message = BuildCommand();
        var bytes = Socket.StartClient(message);

        var bits = new BitArray(bytes);
        var stringBytes = ToBitString(bits);
        SetResultsText(stringBytes + Environment.NewLine);
    }
}, TaskCreationOptions.LongRunning);

await task;

---

如果您无论如何都不想同时运行任务，并且假设有理由不只是同步运行代码，而是完全删除任务，那么在单个任务中按顺序执行所有操作可能会更简单

var task = Task.Factory.StartNew(() =>
{
    foreach(int patient in patients)
    {
        var message = BuildCommand();
        var bytes = Socket.StartClient(message);

        var bits = new BitArray(bytes);
        var stringBytes = ToBitString(bits);
        SetResultsText(stringBytes + Environment.NewLine);
    }
}, TaskCreationOptions.LongRunning);

await task;

---

如果您希望按顺序延迟运行它们，只需执行以下操作：

var first = true;
foreach(int patient in patients)
{
    if (!first)
    {
        await Task.Delay(200);
    }

    await Task.Run(() =>
    {
        var message = BuildCommand();
        var bytes = Socket.StartClient(message);
        var bits = new BitArray(bytes);
        var stringBytes = ToBitString(bits);

        SetResultsText(stringBytes + Environment.NewLine);
    });
 }

---

我想这就是你要问的，但我很怀疑这是你需要的。这只是对线程的浪费。

如果要按顺序延迟运行线程，只需执行以下操作：

var first = true;
foreach(int patient in patients)
{
    if (!first)
    {
        await Task.Delay(200);
    }

    await Task.Run(() =>
    {
        var message = BuildCommand();
        var bytes = Socket.StartClient(message);
        var bits = new BitArray(bytes);
        var stringBytes = ToBitString(bits);

        SetResultsText(stringBytes + Environment.NewLine);
    });
 }

---

我想这就是你要问的，但我很怀疑这是你需要的。这只是对线程的浪费。

使用lock。如果您希望线程按顺序运行，并且任务中没有异步操作，那么为什么要使用任务使事情变得复杂，而不是同步运行代码呢？@PauloMorgado yes。这就是我的意思。我没听到这个词。为我的错误道歉English@Gleb，不要误解你的意思，代码中没有异步。而且，因为它应该是顺序的，所以它会与一定量的线程腰同步。使用lock实现这一点如果你想让它们按顺序运行，并且任务中没有异步操作，为什么要使用任务使事情复杂化，而不只是同步运行代码？@PauloMorgado yes。这就是我的意思。我没听到这个词。为我的错误道歉English@Gleb，不要误解你的意思，代码中没有异步。而且，由于它被认为是连续的，所以它与线腰的剂量同步。