异步编程AsyncAwait简介及应用

最新推荐文章于 2025-05-06 16:30:33 发布

BaeSuzyyy

最新推荐文章于 2025-05-06 16:30:33 发布

阅读量649

点赞数 32

文章标签： c# 经验分享

本文链接：https://blog.csdn.net/Dreamer0221/article/details/147704958

版权

C# 中的 async/await 是 .NET Framework 4.5 引入的异步编程模型（TAP - Task-based Asynchronous Pattern），它允许开发者以近乎同步的方式编写异步代码，极大地简化了异步编程的复杂性。

一简介

1.基本概念

async：修饰方法，表示该方法包含异步操作
await：用于等待一个异步操作完成，只能在 async 方法中使用
Task/Task：表示异步操作，是 await 操作的对象

2.基本示例

public async Task<string> GetWebContentAsync(string url)
{
    using (HttpClient client = new HttpClient())
    {
        // await 会暂停方法执行，但不会阻塞线程
        string content = await client.GetStringAsync(url);
        return content;
    }
}

二工作原理

1.状态机转换

编译器会将 async 方法转换为一个状态机类，其中：
1.方法被拆分为多个部分，每个 await 前后都是一个状态
2.状态机跟踪当前执行位置
3.当异步操作完成时，状态机从暂停的位置继续执行

2.执行流程

1.调用 async 方法时，同步执行直到第一个 await
2.遇到 await 时：
※如果任务已完成，继续同步执行
※如果任务未完成，方法返回一个 Task，剩余代码作为延续任务
3.当 awaited 任务完成后，执行会回到方法中 await 之后的位置

3.线程模型

1.不会阻塞 UI 线程：在 UI 应用程序中，await 后的代码默认会在原同步上下文（如 UI 线程）上恢复
2.线程池线程：在控制台或服务端应用中，延续通常在线程池线程上执行
3.ConfigureAwait(false)：可以指定不在原上下文恢复执行

三具体应用及常见问题

为什么async await不阻塞调用线程，如果调用线程在等待async await的返回值呢

async 和 await 在 C# 中设计的目的是让异步编程变得更简单和直观，同时避免了传统线程阻塞的复杂性。它们使得在异步操作完成之前，调用线程不会被阻塞。下面是一些关键点，解释为什么 async 和 await 不会阻塞调用线程：

1. 非阻塞的异步操作

● await 表达式：当你在 async 方法中使用 await 关键字时，控制流会被释放回调用者。await 表达式会等待异步操作完成，但它不会阻塞调用线程。在等待期间，调用线程可以继续执行其他任务或处理其他工作。
● 异步操作：await 后面的操作通常是非阻塞的异步操作，比如网络请求、文件 I/O、数据库查询等。这些操作不会阻塞线程，因为它们是通过异步机制（如 I/O 完成端口或任务调度器）在后台处理的。

2. 任务的完成和状态

● Task 的状态：await 表达式的实际行为是检查 Task 的状态，如果 Task 已经完成，await 会立即继续执行后续代码。如果 Task 尚未完成，await 会挂起方法的执行，将控制权返回给调用线程，允许线程去执行其他工作或处理其他任务。
● 状态机：编译器会生成一个状态机来处理 async 方法的执行。在 await 处，状态机会保存当前的执行上下文和状态，然后将控制权释放回调用线程。这样调用线程可以继续运行，直到异步操作完成。

3. 同步等待 vs 异步等待

● 同步等待：如果你使用 Task.Wait() 或 Task.Result 等待 Task，这会导致调用线程阻塞，直到 Task 完成。这是一种同步等待方式。
● 异步等待：通过 await 等待 Task，方法会被挂起，调用线程被释放，而不是阻塞。方法的控制流会恢复到 await 表达式之后的位置，一旦 Task 完成。

4. 调用线程的释放

● 线程释放：当 await 遇到尚未完成的 Task 时，它会将调用线程从异步方法中释放出来。这个线程可以用来执行其他工作或处理其他请求。
● 线程池的使用：在后台，异步操作的完成通常会使用线程池中的线程来处理。因此，调用线程不会被长时间占用，系统可以更高效地利用资源。

5. 实际效果

● 用户界面应用：在用户界面（UI）应用中，await 的非阻塞特性允许 UI 线程在等待异步操作完成时继续响应用户交互。这样用户界面不会冻结，提供了更好的用户体验。
● 服务器应用：在服务器应用中，await 使得处理大量并发请求时，线程的利用更加高效，避免了线程阻塞，从而提高了应用的吞吐量和响应速度。
示例：

public async Task<int> DoWorkAsync()
{
    // 模拟异步操作
    await Task.Delay(1000);
    return 42;
}

public async Task CallDoWorkAsync()
{
    // 调用异步方法
    int result = await DoWorkAsync();  // 这里不会阻塞调用线程
    Console.WriteLine(result);
}

在上面的代码中，CallDoWorkAsync 方法调用了 DoWorkAsync。await DoWorkAsync() 让控制权返回给调用线程（比如主线程），而 DoWorkAsync 中的 Task.Delay 是异步执行的。调用线程可以继续处理其他任务，直到 DoWorkAsync 完成。

6.总结

async 和 await 通过释放调用线程的控制权、使用异步操作和状态机，避免了阻塞调用线程。它们提供了一种更优雅的方式来编写异步代码，使得代码更加可读和易于维护，同时允许线程有效地执行其他任务。

如果异步等待之后的操作，需要依赖异步的操作值

当异步操作的结果对后续操作至关重要时，可以使用 await 关键字确保异步操作完成，并且能够安全地使用其结果。下面是如何正确处理这种情况的详细说明和示例：

1.处理异步操作结果的步骤

使用 await 关键字：在 async 方法中使用 await 关键字等待异步操作完成，await 会暂停方法的执行直到异步操作完成，然后继续执行后续代码。这样可以确保异步操作的结果在继续执行后续操作之前已经被获得。
获取异步结果：将异步操作的结果分配给一个变量，这样你可以在后续代码中使用这个结果。
后续操作：在获得异步结果后，使用该结果执行所需的后续操作。

2.示例代码

下面是一个示例，演示如何在异步方法中等待异步操作，并根据结果执行后续操作：

public async Task<int> FetchDataAsync()
{
    // 模拟异步操作，如从数据库或网络获取数据
    await Task.Delay(1000);  // 异步延迟1秒
    return 42;  // 返回操作结果
}

public async Task ProcessDataAsync()
{
    // 调用异步方法并等待其完成
    int result = await FetchDataAsync();
    
    // 使用异步操作的结果进行后续处理
    Console.WriteLine($"The result is: {result}");
}

// 调用异步方法
public async Task RunAsync()
{
    await ProcessDataAsync();
}

3.解释

FetchDataAsync：这是一个异步方法，模拟了一个耗时的操作（如网络请求或数据库查询）。它使用 await Task.Delay(1000) 来模拟异步行为，并返回一个整数值 42。
ProcessDataAsync：这是另一个异步方法，它调用 FetchDataAsync 并使用 await 等待它完成。在 await 表达式之后，result 变量将包含 FetchDataAsync 返回的值 42。然后可以使用这个值进行后续操作，如打印结果。
RunAsync：这是一个用于启动 ProcessDataAsync 方法的异步方法。它确保 ProcessDataAsync 被正确调用和等待完成。

4.关键点

● 异步方法：必须用 async 修饰符标记，并返回 Task 或 Task。
● await 关键字：暂停方法执行，等待异步操作完成，恢复执行时使用异步操作的结果。
● 避免同步等待：尽量避免在异步方法中使用 Task.Wait() 或 Task.Result，因为它们会阻塞调用线程，破坏异步编程模型的优势。
使用 await 关键字，你可以写出既简洁又高效的异步代码，确保异步操作的结果在后续代码中被正确使用，而无需阻塞线程。

同步线程中调用异步方法，是异步吗

在同步线程中调用异步方法，实际上并不会使调用的操作异步执行。这里有几个关键点来帮助理解这个问题：

1.异步方法的调用和同步线程

同步线程调用异步方法：
○ 如果在同步线程中调用一个异步方法（即使是用 await 调用），整个方法的执行过程仍然在同步线程上完成。
○ 异步方法的返回类型是 Task 或 Task，但它的调用本身是同步的。换句话说，虽然异步方法内部的操作是异步的，但在同步线程中调用这个方法，线程会等待直到该异步方法完成。
await 关键字：
○ 在同步线程中调用异步方法时，await关键字会暂停方法的执行，直到异步操作完成。虽然 await 使得方法可以异步等待结果，但实际的调用线程在等待期间会被阻塞（不再执行其他代码，除非使用 await 在其他方法中处理）。
异步执行的线程：
○ 异步操作（如 I/O 操作、网络请求、数据库查询等）是在任务的线程池线程或其他异步上下文中执行的。这意味着，异步方法的实际执行可能是在另一个线程上完成的，但是调用它的同步线程会等待它完成，直到返回结果。

2.示例

public async Task<string> FetchDataAsync()
{
    await Task.Delay(1000);  // 模拟异步操作
    return "Data";
}

public void CallAsyncMethod()
{
    // 同步调用异步方法
    Task<string> task = FetchDataAsync();
    string result = task.Result;  // 阻塞，直到异步操作完成
    Console.WriteLine(result);
}

3.解释

● FetchDataAsync 是一个异步方法，它会在后台线程上等待1秒钟。
● CallAsyncMethod 是一个同步方法，它调用 FetchDataAsync 并使用 task.Result来阻塞当前线程，直到 FetchDataAsync完成。
在这个示例中，尽管 FetchDataAsync 是异步的，CallAsyncMethod 中的 task.Result 使得调用线程阻塞，直到 FetchDataAsync 完成。因此，虽然 FetchDataAsync 内部是异步的，CallAsyncMethod 的调用方式是同步的，因为它等待异步操作完成。

4.总结

● 在同步线程中调用异步方法本身不会使线程变得异步。
● 异步方法可以在内部执行异步操作，但调用和等待结果的线程是同步的，除非使用完全异步的方法（如 await ）来处理操作。
● 如果希望真正利用异步操作的优势，需要在 async 方法中使用 await，并且调用这些方法的上下文也应支持异步编程模型。

await在暂停期间，await后面的代码可以执行吗

在使用 await 关键字时，await 后面的代码在异步操作完成之前不会执行。await 会暂停异步方法的执行，直到异步操作完成，然后再从暂停的地方继续执行。

1.更详细的解释：

暂停执行：当 await 遇到一个异步操作（如 Task），它会暂停当前方法的执行，并将控制权返回到调用方（可能是线程池、UI 线程等）。在等待期间，方法的执行被挂起，但调用线程可以继续处理其他工作。
代码执行顺序： await 后面的代码只会在异步操作完成后执行。例如：

public async Task ExampleMethodAsync()
{
    Console.WriteLine("Start");

    await Task.Delay(2000);  // 异步操作，暂停执行

    Console.WriteLine("End");  // 仅在异步操作完成后执行
}

在这个例子中，“Start” 会被立即打印，但 “End” 只有在 Task.Delay(2000) 完成后才会打印。这意味着 await 后面的代码在异步操作完成之前不会执行。
3. 线程释放： await 会释放当前线程，使得它可以处理其他任务。异步操作完成后，线程（或任务的上下文）会恢复到 await 关键字后的代码。

2.·示例

public async Task FetchDataAsync()
{
    Console.WriteLine("Fetching data...");

    await Task.Delay(3000);  // 异步操作，模拟网络请求

    Console.WriteLine("Data fetched.");
}

在调用 FetchDataAsync 时：

public async Task CallFetchDataAsync()
{
    Console.WriteLine("Start");

    await FetchDataAsync();  // FetchDataAsync 会暂停执行直到 Task.Delay 完成

    Console.WriteLine("End");
}

执行顺序如下：

输出 “Start”。
调用 FetchDataAsync，输出 “Fetching data…”。
FetchDataAsync 暂停，直到 Task.Delay完成。
在 Task.Delay 完成后，FetchDataAsync继续执行，输出 “Data fetched.”。
然后 CallFetchDataAsync 继续执行，输出 “End”。

3.总结

await 会暂停方法的执行，直到异步操作完成。await 后面的代码只有在异步操作完成后才会执行。在暂停期间，线程不会被阻塞，可以处理其他任务。

如果在await时，调用线程依赖await的返回值，调用线程也会等待吗

如果调用线程依赖于 await 的返回值，调用线程会等待异步操作完成，直到 await 关键字后的代码执行完毕。在这种情况下，调用线程会被“暂停”直到 await 完成，但这种暂停并不是阻塞线程，而是依赖于异步操作的完成。

1.更详细的解释

等待返回值：当你使用 await 关键字时，调用线程会等待异步操作的完成。如果异步方法返回一个结果，调用线程在 await 语句处会暂停，直到异步操作完成并返回结果。
异步操作的完成： await 会解包 Task 或 Task 对象，并等待其完成。如果异步方法需要返回一个值，await 将会等待这个值被计算出来，并在值可用时继续执行。
线程的状态：
○ 在 await 关键字处，异步方法的执行会被挂起，直到任务完成。
○ 调用线程不会被阻塞，而是可以继续执行其他任务。在 await 完成之前，当前异步方法会被“挂起”。

2.示例

假设有一个异步方法返回一个 int 值：

public async Task<int> CalculateValueAsync()
{
    await Task.Delay(2000);  // 模拟一个耗时操作
    return 42;
}

调用它的方法：

public async Task UseValueAsync()
{
    Console.WriteLine("Start");

    int result = await CalculateValueAsync();  // 这里会等待 CalculateValueAsync 完成

    Console.WriteLine($"Result is: {result}");  // 在 CalculateValueAsync 完成后执行
    Console.WriteLine("End");
}

3.执行顺序

UseValueAsync 被调用，输出 “Start”。
await CalculateValueAsync() 处会暂停 UseValueAsync 的执行，直到 CalculateValueAsync 完成并返回值。
CalculateValueAsync 先输出“开始计算”，然后在 2 秒后返回值 42。
await 在 CalculateValueAsync 完成后接收到返回值 42，UseValueAsync 继续执行，输出 Result is: 42。
最后输出 “End”。

4.总结

● 在 await 处，调用线程会等待异步操作完成，如果 await 的操作需要返回值，调用线程会在 await 处“暂停”，直到结果可用；如果调用线程不需要返回值，则可以直接执行后面的代码，不用等待被调用函数的完成。
● 这种暂停不会阻塞线程，而是使线程能够继续执行其他任务，直到异步操作完成。await 后的代码在异步操作完成之前不会执行。

注意： await后面不能跟void方法，因为不能等待void方法执行完成。