数据准备(阻塞和非阻塞)、数据读写(同步和异步)

无论是什么样的IO都包含两个阶段：数据准备和数据读写。

我们的网络IO也是同样的，

数据准备：根据系统IO操作的就绪状态（这是在操作系统的角度来讲的）

• 阻塞
  调用IO方法的线程进入则色状态，
  如果没有数据可读，recv函数是不会返回的，一直等待这个fd上的读缓冲区上被激活；如果它返回说明有数据可以读，接着就是数据读写，走向阶段二：数据读写。
• 非阻塞
  不会改变线程的状态，通过返回值判断
  如果说我把sockfd设置成非阻塞，recv会直接返回，不会造成当前线程的阻塞

总而言之，我们会在这里编写一个循环，不断让CPU空转，只有真正收到数据的时候才会返回。

//默认阻塞
int size = recv(int socket, void *buffer, size_t length, int flags);
int size = recv(sockfd, buf, 1024, 0);

//如果sockfd被设置成非阻塞状态，我们这样去运行程序
//返回值如果是-1，说明有内部错误
size == -1 && errno = EAGAIN//表示连接上了但是远端没有数据，返回的原因是非阻塞IO返回
size == 0 //远端断开链接
size > 0 //表示有这么多数据可读

数据读写：根据应用程序和内核的交互方式（这是在应用层程序的角度讲的）
int size = recv(int socket, void *buffer, size_t length, int flags);
int size = recv(sockfd, buf, 1024, 0);
无论是阻塞模式还是非阻塞模式，只要数据没到，我们是都没有数据可以读的。
等到TCP接受缓冲区（内核）有数据了，说明数据可读，那么我们的recv函数开始接收数据，通过调用这个函数，内核中的数据就开始往用户层的这个buf里面搬运。这里的返回值size就是返回了多少数据。
那么是让操作系统给我读好还是我自己去读呢？其中的参数buf，是用户层的自己定义的buf.

• 同步
  等到TCP接受缓冲区（内核）有数据了，说明数据可读，那么我们的recv函数开始接收数据，通过调用这个函数，内核中的数据就开始往用户层的这个buf里面搬运。这里的返回值size就是返回了多少数据。
  如果recv没有把内核中缓冲区数据全部搬完的话，是不会返回的。
  这就叫IO同步

char buf[1024] = 0;
int size = recv(sockfd, buf, 1024, 0);
if (size > 0) {
	buf
}

• 异步

关于数据的异步读写就不能用recv来举例了，因为recv和send都是同步的IO接口。
异步IO的效率确实高，但是程序比较复杂，出问题的话也不太好定位错误。

所谓的异步IO接口就是，首先得有一个sockfd，如果该文件描述符上的数据可读，需要把内核中读缓冲区的数据搬到buf中(操作系统来完成，在同步IO中，是我们自己花时间搬的)，如果操作系统完成了所有数据的搬运，通过sigio信号通知应用程序即可。

所以我们的应用程序可以完成自己的业务逻辑。等到sigio通知（这个通知不一定是信号，还可以通过回调函数），这个时候说明IO已经准备好了，我们再去执行即可。这是我们异步编程的最大核心。

也就是说我们把数据读写全部委托给了操作系统，不同于之前的同步IO接口，要么就是阻塞在recv，要么就是在循环中空转CPU，等待TCP接收缓冲区全部写入buf。（这里老师举了一个坐飞机取机票的例子来总结同步和异步IO，非常简单形象）

两个典型的异步IO接口：aio_read,aio_write

小总结（陈硕老师的总结）

陈硕大神的原话：在处理IO：在处理 IO 的时候，阻塞和非阻塞都是同步 IO。只有使用了特殊的 API 才是异步 IO。

知识拓展

在我们应用程序进行多线程多进程处理的时候，也就是业务层面的一个并发的同步和异步如何区分呢？

同步：A等待B做完事情，得到返回值，然后继续处理
异步：A操作告诉B操作它感兴趣的事件以及同时方式，A操作继续执行自己的业务逻辑了；等B监听到响应事件发生后，B会通知A，A开始处理响应的数据处理逻辑

同步执行实例

这个示例中，A 等待 B 完成一个任务（如计算一个值），然后使用这个值继续其他操作。

#include <iostream>
#include <thread>
#include <chrono>

int performTask(int x) {
    // 模拟耗时任务
    std::this_thread::sleep_for(std::chrono::seconds(2));
    return x * x; // 返回 x 的平方
}

int main() {
    std::cout << "A starts and waits for B to complete..." << std::endl;
    int result = performTask(5); // A 等待 B 完成
    std::cout << "B completed with result: " << result << std::endl;
    std::cout << "A continues with result." << std::endl;

    // 使用结果进行其他操作
    std::cout << "Final result: " << result * 2 << std::endl;

    return 0;
}

异步编程实例

在这个例子中，A 操作发起一个任务给 B，并且继续执行其他事情。当 B 完成任务时，它将结果返回给 A，然后 A 处理这个结果。

#include <iostream>
#include <future>
#include <chrono>

int performAsyncTask(int x) {
    // 模拟耗时任务
    std::this_thread::sleep_for(std::chrono::seconds(2));
    return x * x; // 返回 x 的平方
}

int main() {
    std::cout << "A starts and does not wait for B..." << std::endl;
    std::future<int> futureResult = std::async(std::launch::async, performAsyncTask, 5);

    // A 继续执行其他操作
    std::cout << "A is doing other things..." << std::endl;
    std::this_thread::sleep_for(std::chrono::seconds(1)); // 模拟 A 执行其他任务
    std::cout << "A is still working..." << std::endl;

    // 等待 B 完成并获取结果
    int result = futureResult.get();
    std::cout << "B completed with result: " << result << std::endl;
    std::cout << "A processes the result." << std::endl;

    // 使用结果进行其他操作
    std::cout << "Final result: " << result * 2 << std::endl;

    return 0;
}

在异步示例中，std::async 创建了一个异步任务，它允许 A 继续执行而不必等待 B 完成。一旦需要结果时，通过调用 futureResult.get() 获取，这将会阻塞直到异步任务完成。在多线程编程中，如果我们的A线程并不关心B线程的返回值和状态，我们甚至可以A直接退出。

八股

首先阐述什么是阻塞、非阻塞、同步、异步：
阻塞非阻塞同步异步描述的都是IO的状态，一个典型的网络IO包含两个阶段，数据准备和数据读写；

举例说明：
比如说recv传一个sockfd,buf,buf的大小，

数据准备
数据准备就是说远端是否有数据过来，内核的TCP接受缓冲区中是否有数据可读，

阻塞和非阻塞
当sockfd工作在阻塞模式下的话，当我调用recv如果数据没有就绪，就会阻塞当前的线程，如果sockfd工作在非阻塞状态下，我们调用系统IO接口就会立即返回，如果返回值是-1说明链接异常；
如果工作在非阻塞，我们往往会写一个错误好EAGAIN来捕捉该错误，返回值是0说明连接中断，返回值>0值得就是我们读的数据大小。

数据就绪
如果说远端数据已经准备好了，说明我们需要进行数据的读写，

同步和异步
这个时候操作系统会帮我们把内核的TCP接受缓冲区写入到recv的buf参数中，只有写完了，也就是说我们的应用程序必须等待它拷贝完成，recv才返回，才能执行后续的运行逻辑，这就是同步IO；
如果我们调用aio_read接口就是异步IO，此时我们的线程可以继续执行后面的应用程序逻辑，等到缓冲区数据全部写入到我们的buf中去的时候，aio_read会发送一个sigio信号来告诉我们读数据完毕。这个sigio不仅可以是一个信号，也可以通过回调函数来实现。

在我们应用程序业务层面的并发编程也涉及到同步和异步，虽然角度不同，但是大体的逻辑是一致的，同步的话A程序必须等待B程序执行完毕，异步的话他们可以各自处理自己的业务逻辑，等B执行完，通知A即可