在我阅读有关 .Net 4.5 中的异步编程的过程中 async和 await关键词 我读了Here以下段落

Processing Asynchronous Requests

In web applications that sees a large number of concurrent requests at start-up or has a bursty load (where concurrency increases suddenly), making these web service calls asynchronous will increase the responsiveness of your application. An asynchronous request takes the same amount of time to process as a synchronous request. For example, if a request makes a web service call that requires two seconds to complete, the request takes two seconds whether it is performed synchronously or asynchronously. However, during an asynchronous call, a thread is not blocked from responding to other requests while it waits for the first request to complete. Therefore, asynchronous requests prevent request queuing and thread pool growth when there are many concurrent requests that invoke long-running operations.

对于粗体字，我无法理解为什么异步请求需要与同步请求相同的时间来处理？

例如:

public async Task MyMethod()
{
    Task<int> longRunningTask = LongRunningOperation();
    //indeed you can do independent to the int result work here 

    //and now we call await on the task 
    int result = await longRunningTask;
    //use the result 
    Console.WriteLine(result);
}

public async Task<int> LongRunningOperation() // assume we return an int from this long running operation 
{
    await Task.Delay(1000); //1 seconds delay
    return 1;
}

我的理解LongRunningOperation()从这里调用的第一行开始执行 Task<int> longRunningTask = LongRunningOperation();并在调用 await 后返回值, 所以从我的角度来看，异步代码比同步代码快，对吗？

另一个问题:

据我所知，主线程正在执行 MyMethod()未阻塞等待 LongRunningOperation()待完成但它返回到线程池以服务于另一个请求。那么是否有另一个线程分配给LongRunningOperation();执行它？

如果是那么异步编程和多线程编程有什么区别？

更新:

假设代码变成这样:

public async Task MyMethod()
    {
        Task<int> longRunningTask = LongRunningOperation();
        //indeed you can do independent to the int result work here 
        DoIndependentWork();
        //and now we call await on the task 
        int result = await longRunningTask;
        //use the result 
        Console.WriteLine(result);
    }

    public async Task<int> LongRunningOperation() // assume we return an int from this long running operation 
    {
        DoSomeWorkNeedsExecution();
        await Task.Delay(1000); //1 seconds delay
        return 1;
    }

在这种情况下，将 LongRunningOperation()在 DoIndependentWork() 期间由另一个线程执行执行？

最佳答案

异步操作并不快。如果您异步(即 await Task.Delay(10000))或同步(即 Thread.Sleep(10000))等待 10 秒，将花费相同的时间10 秒。唯一的区别是，第一个在等待时不会占用线程，但第二个会占用线程。

现在，如果您启动一个任务并且不等待它立即完成，您可以使用同一个线程来做一些其他工作，但它不会“加速”异步操作的运行:

var task = Task.Delay(10000);
// processing
await task; // will complete only after 10 seconds

关于您的第二个问题:Task.Delay(与其他真正的异步操作一样)不需要执行线程，因此 there is no thread . Task.Delay 是使用您启动的 System.Threading.Timer 实现的，它会在完成时引发一个事件，同时它不需要线程，因为没有可执行的代码。

因此，当运行 MyMethod 的线程到达 await longRunningTask 时，它会被释放(只要 longRunningTask 尚未完成) .如果它是一个 ThreadPool 线程，它将返回到 ThreadPool，它可以在您的应用程序中处理一些其他代码。

关于更新的流程是这样的:

• MyMethod 开始处理
• LongRunningOperation 开始处理
• DoSomeWorkNeedsExecution 在调用线程上执行
• 在 LongRunningOperation 中到达一个 await，因此返回一个热任务。
• DoIndependentWork 由同一个调用线程执行(LongRunningOperation 仍在“运行”，不需要线程)
• 在 MyMethod 中到达了一个 await。如果原始任务完成，同一个线程将同步继续，否则将返回一个最终完成的热任务。

因此，您使用 async-await 的事实允许您使用一个线程，否则该线程将被阻塞以同步等待执行 CPU 密集型工作。

关于c# - .net 4.5 中异步和同步的区别，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/27742698/