看看微软怎么说。

The core of async programming is the Task and Task objects, which model asynchronous operations. They are supported by the async and await keywords. The model is fairly simple in most cases: For I/O-bound code, you await an operation which returns a Task or Task inside of an async method. For CPU-bound code, you await an operation which is started on a background thread with the Task.Run method. The await keyword is where the magic happens. It yields control to the caller of the method that performed await, and it ultimately allows a UI to be responsive or a service to be elastic.

I/ o绑定示例:从web服务下载数据

private readonly HttpClient _httpClient = new HttpClient();

downloadButton.Clicked += async (o, e) =>
{
    // This line will yield control to the UI as the request
    // from the web service is happening.
    //
    // The UI thread is now free to perform other work.
    var stringData = await _httpClient.GetStringAsync(URL);
    DoSomethingWithData(stringData);
};

cpu受限示例:为游戏执行计算

private DamageResult CalculateDamageDone()
{
    // Code omitted:
    //
    // Does an expensive calculation and returns
    // the result of that calculation.
}

calculateButton.Clicked += async (o, e) =>
{
    // This line will yield control to the UI while CalculateDamageDone()
    // performs its work.  The UI thread is free to perform other work.
    var damageResult = await Task.Run(() => CalculateDamageDone());
    DisplayDamage(damageResult);
};

Examples above showed how you can use async and await for I/O-bound and CPU-bound work. It's key that you can identify when a job you need to do is I/O-bound or CPU-bound, because it can greatly affect the performance of your code and could potentially lead to misusing certain constructs. Here are two questions you should ask before you write any code: Will your code be "waiting" for something, such as data from a database? If your answer is "yes", then your work is I/O-bound. Will your code be performing a very expensive computation? If you answered "yes", then your work is CPU-bound. If the work you have is I/O-bound, use async and await without Task.Run. You should not use the Task Parallel Library. The reason for this is outlined in the Async in Depth article. If the work you have is CPU-bound and you care about responsiveness, use async and await but spawn the work off on another thread with Task.Run. If the work is appropriate for concurrency and parallelism, you should also consider using the Task Parallel Library.

这很直观:

如果一个程序在CPU更快的情况下运行得更快，那么它就受到了CPU的限制，也就是说，它的大部分时间都在简单地使用CPU(进行计算)。计算π的新数字的程序通常是cpu限制的，它只是处理数字。

如果一个程序能够在I/O子系统更快的情况下运行得更快，那么它就是I/O约束的。具体的I/O系统是不同的;我通常把它与磁盘联系在一起，当然，一般来说，网络或通信也很常见。在一个大文件中查找一些数据的程序可能会成为I/O限制，因为瓶颈是从磁盘读取数据(实际上，这个例子在今天可能有点过时，从ssd读取数百MB/s)。

当你的程序正在等待I/O(即。磁盘读/写或网络读/写等)，即使程序停止，CPU也可以自由地执行其他任务。程序的速度主要取决于IO发生的速度，如果你想加快速度，就需要加快I/O。

如果你的程序正在运行大量的程序指令而不等待I/O，那么它就被称为CPU限制。加速CPU将使程序运行得更快。

在任何一种情况下，加速程序的关键可能不是加快硬件，而是优化程序以减少所需的IO或CPU数量，或者让它在执行CPU密集型操作的同时执行I/O。

CPU限制是指进程的速度受CPU速度的限制。对一小组数字执行计算的任务，例如乘小矩阵，可能会受到CPU的限制。

I/O约束是指进程的速度受I/O子系统的速度限制。处理来自磁盘的数据的任务(例如，计算文件中的行数)可能受到I/O限制。

内存限制是指进程进程的速度受可用内存数量和内存访问速度的限制。处理大量内存内数据的任务，例如乘法大型矩阵，很可能是memory Bound。

缓存约束是指进程进程受可用缓存数量和速度限制的速率。如果一个任务处理的数据超过了缓存的容量，那么它就会被缓存绑定。

I/O绑定比内存绑定慢，缓存绑定比CPU绑定慢。

I/O受限的解决方案不一定是获得更多内存。在某些情况下，访问算法可以围绕I/O、内存或缓存限制进行设计。参见缓存无关算法。

IO绑定进程:花更多的时间做IO比计算，有很多 短CPU突发。 CPU绑定进程:花费更多的时间进行计算，很少有很长时间的CPU爆发

另一种表达相同想法的方式是:

如果加速CPU并没有加速你的程序，它可能是I/O受限的。 如果加速I/O(例如使用更快的磁盘)没有帮助，那么您的程序可能是CPU受限的。

(我使用“可能是”是因为你需要考虑其他资源。内存就是一个例子。)