Task.Wait详解

一、Task.WaitAll用法

Task.WaitAll方法使得当前线程阻塞，直到传入参数的所有Task完成。具体来说，Task.WaitAll方法是从任务数组中执行工作的。下面是一个示例代码：

Task[] tasks = new Task[3];
tasks[0] = Task.Run(() => DoSomeWork(1000));
tasks[1] = Task.Run(() => DoSomeWork(2000));
tasks[2] = Task.Run(() => DoSomeWork(3000));
Task.WaitAll(tasks);

上面的代码中，DoSomeWork方法模拟了执行一些工作，并传入了一个参数作为工作的时间间隔。在代码中创建了一个包含三个Task的数组，分别模拟执行时间为1秒、2秒和3秒的工作。最后，通过Task.WaitAll等待三个Task都完成。注意，Task.WaitAll方法会阻塞当前线程，直到所有任务都完成。

二、Task.Wait和Task.Result的区别

Task.Wait方法和Task.Result方法都可以用于等待Task完成，并获取Task的结果。它们的区别在于Task.Result方法会阻塞线程，直到Task完成并返回结果。而Task.Wait方法则不会返回结果，只会等待Task完成。下面是一个示例代码：

Task<int> task = Task.Run(() => DoSomeWork(1000));
// 使用 Task.Result 获取结果
int result = task.Result;
// 使用 Task.Wait 等待任务完成
task.Wait();

上面的代码中，Task.Run方法创建了一个Task，并执行DoSomeWork方法。在代码中使用Task.Result获取Task的结果，并将其赋值给result变量。当Task没有完成时，调用Task.Result方法会阻塞线程，直到Task完成并返回结果。而使用Task.Wait方法，虽然也会等待Task完成，但不会返回结果。

三、Task.Wait和await

Task.Wait方法和await关键字都可以等待异步任务完成。它们的区别在于，Task.Wait方法会阻塞当前线程，直到任务完成。而使用await关键字，会在等待任务完成的同时释放线程，使得线程可以执行其他任务。下面是一个示例代码：

async Task<int> MyAsyncMethod()
{
    await Task.Delay(1000);
    return 123;
}

// 使用 Task.Wait 等待任务完成
Task<int> task = MyAsyncMethod();
task.Wait();
// 使用 await 等待任务完成
int result = await MyAsyncMethod();

上面的代码中，MyAsyncMethod模拟了一个异步任务，并使用Task.Delay方法等待一段时间。在代码中，Task.Wait方法会阻塞当前线程，直到任务完成。而使用await关键字，虽然也会等待任务完成，但在等待任务完成的同时，释放当前线程，使线程可以执行其他任务。

四、Task.Wait和await的区别

Task.Wait方法和await关键字都可以等待异步任务完成。但二者的区别在于，Task.Wait方法会阻塞线程，直到任务完成。而使用await关键字会在等待异步任务完成的同时，释放线程，使得线程可以执行其他的任务。下面是一个示例代码：

async Task<int> MyAsyncMethod()
{
    await Task.Delay(1000);
    return 123;
}

// 使用 Task.Wait 等待任务完成
Task<int> task = MyAsyncMethod();
task.Wait();
// 使用 await 等待任务完成
int result = await MyAsyncMethod();

上面的代码中，MyAsyncMethod方法模拟了一个异步任务。在代码中，Task.Wait方法会阻塞当前线程，直到异步任务完成。而使用await关键字，等待异步任务完成的同时，释放当前线程，使得线程可以执行其他的任务。

五、Task.WaitAll多次调用

Task.WaitAll方法可以多次调用以等待不同的Task完成。下面是一个示例代码：

Task[] tasks1 = new Task[3];
tasks1[0] = Task.Run(() => DoSomeWork(1000));
tasks1[1] = Task.Run(() => DoSomeWork(2000));
tasks1[2] = Task.Run(() => DoSomeWork(3000));

Task[] tasks2 = new Task[1];
tasks2[0] = Task.Run(() => DoSomeOtherWork(5000));

// 等待两个 Task 完成
Task.WaitAll(tasks1);
Task.WaitAll(tasks2);

上面的代码中，Task.Run方法分别创建了两个包含不同数目Task的数组，每个Task模拟了执行不同的工作。在代码中，通过Task.WaitAll方法等待所有的Task完成。

六、Task.WaitAll有一个没有执行

Task.WaitAll方法会等待所有传入的Task都完成。如果其中有一个Task没有执行，将会一直等待下去。下面是一个示例代码：

Task[] tasks = new Task[3];
tasks[0] = Task.Run(() => DoSomeWork(1000));
tasks[1] = Task.Run(() => DoSomeWork(2000));

Task.WaitAll(tasks);

上面的代码中，只有两个Task被创建，并且模拟了执行工作。在代码中，Task.WaitAll方法等待所有Task完成，但实际上只有两个Task被创建。这种情况下，等待会一直持续下去，直到超时或者程序被终止。

七、Task.WaitAll会阻塞主线程c#

Task.WaitAll方法会阻塞当前线程，直到传入的所有Task完成。如果在主线程中调用此方法，并且其中某些Task正在执行I/O操作或者睡眠等待，将会导致主线程被阻塞并且无法响应用户输入。下面是一个示例代码：

async Task<int> DoSomeWorkAsync()
{
    await Task.Delay(5000);
    return 123;
}

Task[] tasks = new Task[3];
tasks[0] = DoSomeWorkAsync();
tasks[1] = Task.Run(() => DoSomeWork(2000));
tasks[2] = Task.Run(() => DoSomeWork(3000));
Task.WaitAll(tasks);

上面的代码中，DoSomeWorkAsync方法模拟了一个I/O操作，Task.Run方法创建了两个Task模拟了执行工作。在代码中，Task.WaitAll方法会等待所有Task完成，包括在DoSomeWorkAsync方法中执行的异步I/O操作。这将导致主线程被阻塞，并且无法响应用户输入。

八、Task.WaitAll不等待所有线程完成

Task.WaitAll方法不保证等待所有Task都完成。任务可能会因为一些原因完成失败（比如抛出异常），从而让Task.WaitAll方法提前返回。下面是一个示例代码：

Task[] tasks = new Task[3];
tasks[0] = Task.Run(() => DoSomeWorkThatThrowsException());
tasks[1] = Task.Run(() => DoSomeWork(2000));
tasks[2] = Task.Run(() => DoSomeWork(3000));
Task.WaitAll(tasks);

上面的代码中，只有两个Task被创建，并且模拟了一个会抛出异常的Task。在代码中，Task.WaitAll方法等待所有Task完成，但由于一个Task抛出了异常，Task.WaitAll方法会提前返回，而不会等待其他Task完成。需要注意的是，使用Task.WaitAll方法等待多个Task时，等待的过程中任意一个Task抛出异常，将会导致Task.WaitAll方法提前返回。

九、Task.WaitAny

Task.WaitAny方法允许等待多个Task，直到其中任意一个完成。下面是一个示例代码：

Task[] tasks = new Task[3];
tasks[0] = Task.Run(() => DoSomeWork(1000));
tasks[1] = Task.Run(() => DoSomeWork(2000));
tasks[2] = Task.Run(() => DoSomeWork(3000));
Task.WaitAny(tasks);

上面的代码中，Task.Run方法创建了三个Task，其中每个Task模拟了执行不同时间间隔的工作。在代码中，Task.WaitAny方法等待任意一个Task完成，并且当其中一个Task完成时，Task.WaitAny方法立即返回。

十、Task.WaitAll和WhenAll

Task.WaitAll方法和Task.WhenAll方法都可以等待所有Task完成，但二者的区别在于Task.WhenAll方法会立即返回。下面是一个示例代码：

Task[] tasks = new Task[3];
tasks[0] = Task.Run(() => DoSomeWork(1000));
tasks[1] = Task.Run(() => DoSomeWork(2000));
tasks[2] = Task.Run(() => DoSomeWork(3000));

// 使用 Task.WaitAll 等待任务完成
Task.WaitAll(tasks);

// 使用 Task.WhenAll 等待任务完成
await Task.WhenAll(tasks);

上面的代码中，Task.Run方法创建了三个Task，代码中分别使用Task.WaitAll方法和Task.WhenAll方法等待所有Task完成。Task.WaitAll方法会阻塞当前线程，直到所有Task完成。而Task.WhenAll方法会立即返回一个新Task，并在所有Task完成后该Task完成。