Die Betriebsumgebung dieses Tutorials: Linux5.9.8-System, Dell G3-Computer.
Wir alle wissen, dass in der Linux-Welt alles eine Datei ist.
Und eine Datei ist eine Reihe von Binärströmen, egal ob Socket, FIFO, Pipe oder Terminal, für uns ist alles ein Stream.
Im Prozess des Informationsaustauschs führen wir alle Datensende- und -empfangsvorgänge für diese Streams durch, die als E/A-Vorgänge bezeichnet werden.
Daten aus dem Stream lesen, das System ruft Read auf, Daten schreiben und das System ruft Write auf. 🔜 Da die Anwendung im Benutzerbereich ausgeführt wird, können die beiden keine Zeiger zum Übertragen von Daten verwenden, da der von Linux verwendete „virtuelle Speicher“-Mechanismus den Kernel über Systemaufrufe anfordern muss, um E/A-Aktionen abzuschließen.
Warum ein IO-Modell benötigt wird
Wenn Sie
synchron
zur Kommunikation verwenden, werden alle Vorgänge nacheinander in einem Thread ausgeführt. Die Nachteile liegen auf der Hand: 
Da synchrone Kommunikationsvorgänge alle anderen Vorgänge blockieren Im selben Thread können nachfolgende Vorgänge erst nach Abschluss dieses Vorgangs abgeschlossen werden, also
synchrones Blockieren + Multithreading
(jeder Socket erstellt einen entsprechenden Thread), aber die Anzahl der Threads im System ist Es gibt Einschränkungen und Threads Das Umschalten ist gleichzeitig Zeitverschwendung und eignet sich daher für Situationen, in denen nur wenige Steckdosen vorhanden sind. 
Das IO-Modell muss angezeigt werden.
Linux IO-Modell
Bevor wir das Linux IO-Modell beschreiben, wollen wir zunächst den Prozess des Lesens von Linux-Systemdaten verstehen:
Nehmen Sie als Beispiel den Benutzer, der die Datei index.html anfordert
-
Grundlegende Konzepte: Benutzerraum und Kernelraum
Um die Sicherheit des Kernels zu gewährleisten, können Benutzerprozesse den Kernel nicht direkt bedienen. Das Betriebssystem unterteilt den virtuellen Raum in zwei Teile, einen in den Kernelraum und einen in den Benutzerraum.
Prozesswechsel
Um die Ausführung eines Prozesses zu steuern, muss der Kernel in der Lage sein, den auf der CPU laufenden Prozess anzuhalten und die Ausführung eines zuvor angehaltenen Prozesses fortzusetzen. 
Dieses Verhalten wird als Prozessumschaltung bezeichnet.
Man kann also sagen, dass jeder Prozess mit der Unterstützung des Betriebssystemkernels läuft und eng mit dem Kernel verbunden ist.
Prozessblockierung
Der ausgeführte Prozess, weil bestimmte erwartete Ereignisse nicht eintreten, wie z. B. das Versäumnis, Systemressourcen anzufordern, das Warten auf den Abschluss eines bestimmten Vorgangs, das Eintreffen neuer Daten oder das Fehlen neuer Aufgaben usw ., wird vom System blockiert. Führen Sie das Blockierungsprimitiv (Block) automatisch aus, um vom Betriebszustand in den Blockierungszustand zu wechseln. Es ist ersichtlich, dass das Blockieren eines Prozesses ein aktives Verhalten des Prozesses selbst ist und daher nur ein Prozess im laufenden Zustand (der die CPU erhält) ihn in einen blockierten Zustand versetzen kann.
Wenn der Prozess in den Blockierungszustand wechselt, belegt er keine CPU-Ressourcen.
Dateideskriptor
Dateideskriptor (Dateideskriptor) ist ein Begriff aus der Informatik und ein abstraktes Konzept, das verwendet wird, um einen Verweis auf eine Datei auszudrücken.
Der Dateideskriptor ist in seiner Form eine nicht negative Ganzzahl. Tatsächlich handelt es sich um einen Indexwert, der auf die vom Kernel für jeden Prozess verwaltete Datensatztabelle der Dateien verweist.
Wenn ein Programm eine vorhandene Datei öffnet oder eine neue Datei erstellt, gibt der Kernel einen Dateideskriptor an den Prozess zurück.
Cached IO
Der Standard-IO-Vorgang für die meisten Dateisysteme ist zwischengespeicherte IO.
Der Lese- und Schreibvorgang läuft wie folgt ab:
Lesevorgang: Das Betriebssystem prüft, ob der Puffer des Kernels über die erforderlichen Daten verfügt. Wenn diese zwischengespeichert wurden, werden sie direkt aus dem Cache zurückgegeben. Andernfalls werden sie von der Festplatte, der Netzwerkkarte usw. gelesen ., und dann im Puffer des Betriebssystems zwischengespeichert
Schreibvorgang: Daten aus dem Benutzerbereich in den Cache im Kernelbereich kopieren. Zu diesem Zeitpunkt ist der Schreibvorgang für das Benutzerprogramm abgeschlossen. Der Zeitpunkt des Schreibens auf die Festplatte, die Netzwerkkarte usw. wird vom Betriebssystem bestimmt, es sei denn, der Synchronisierungsbefehl sync wird explizit aufgerufen.
- Phase 1:
Das Kernel-Programm liest Daten von der Festplatte oder dem Netzwerk Karte usw. in den Kernel-Space-Cache-Bereich ;
- Phase 2:
Das Benutzerprogramm kopiert Daten aus dem Kernel-Space-Cache in den Benutzerbereich.
Nachteile von zwischengespeicherten E/A-Vorgängen:
Daten müssen während des Übertragungsprozesses mehrmals in den Anwendungsadressraum und den Kernelraum kopiert werden. Der durch diese Datenkopiervorgänge verursachte CPU- und Speicheraufwand ist sehr groß.
Synchronisierte Blockierung
Die User-Space-Anwendung führt einen Systemaufruf aus, der dazu führt, dass die Anwendung blockiert und nichts unternimmt, bis die Daten bereit sind. Die Daten werden vom Kernel in den Benutzerprozess kopiert und schließlich verarbeitet der Prozess die Daten In den beiden Phasen des Wartens auf Daten und der Verarbeitung von Daten ist der gesamte Prozess blockiert und kann keine anderen Netzwerk-E/A verarbeiten.
Die aufrufende Anwendung befindet sich in einem Zustand, in dem sie keine CPU mehr verbraucht und lediglich auf eine Antwort wartet. Aus Verarbeitungssicht ist dies also sehr effizient.
- Dies ist auch das einfachste IO-Modell. Es ist kein Problem, es zu verwenden, wenn normalerweise nur wenige FDs vorhanden sind und die Bereitschaft schnell erfolgt.
Synchron nicht blockierend
Nachdem der nicht blockierende Systemaufruf aufgerufen wurde, wird der Prozess nicht blockiert und der Kernel kehrt sofort zum Prozess zurück. Wenn die Daten noch nicht bereit sind, wird hier ein Fehler zurückgegeben Zeit.
Nachdem der Prozess zurückgekehrt ist, kann er andere Dinge tun, bevor er einen Systemaufruf durchführt. O_NONBLOCK auf den Socket setzen. O_NONBLOCK即可。
IO多路复用
IO多路复用，这是一种进程预先告知内核的能力，让内核发现进程指定的一个或多个IO条件就绪了，就通知进程。
使得一个进程能在一连串的事件上等待。
IO复用的实现方式目前主要有Select、Poll和Epoll。
伪代码描述IO多路复用：
while(status == OK) { // 不断轮询 ready_fd_list = io_wait(fd_list); //内核缓冲区是否有准备好的数据 for(fd in ready_fd_list) { data = read(fd) // 有准备好的数据读取到用户缓冲区 process(data) }}Nach dem Login kopieren
信号驱动
首先我们允许Socket进行信号驱动IO，并安装一个信号处理函数，进程继续运行并不阻塞。
当数据准备好时，进程会收到一个SIGIO信号，可以在信号处理函数中调用I/O操作函数处理数据。
流程如下：
此种IO方式存在的一个很大的问题：Linux中信号队列是有限制的，如果超过这个数字问题就无法读取数据
异步非阻塞
异步IO流程如下所示：
-
当用户线程调用了aio_read
IO-Multiplexing
IO-Multiplexing ist die Fähigkeit eines Prozesses, den Kernel im Voraus zu informieren, sodass der Kernel erkennen kann, dass eine oder mehrere vom Prozess angegebene E/A-Bedingungen bereit sind , benachrichtigen Sie den Prozess.
-
Zu den wichtigsten Implementierungsmethoden der IO-Wiederverwendung gehören derzeit Select, Poll und Epoll.
rrreee
Signaltreiber
Zuerst erlauben wir Socket, signalgesteuertes IO auszuführen und eine Signalverarbeitungsfunktion zu installieren. Der Prozess läuft ohne Blockierung weiter.
🎜Wenn die Daten bereit sind, empfängt der Prozess ein SIGIO-Signal und kann die E/A-Operationsfunktion in der Signalverarbeitungsfunktion aufrufen, um die Daten zu verarbeiten. 🎜🎜🎜Der Prozess ist wie folgt: 🎜🎜🎜🎜🎜Aktivieren Sie die E/A-Funktion des Socket-Signaltreibers. 🎜🎜🎜🎜Das System ruft Sigaction auf, um die Signalverarbeitungsfunktion auszuführen (nicht blockierend, sofort zurückkehren). Bereit, generieren Sie das Sigio-Signal und geben Sie das Signal weiter. Die Rückrufbenachrichtigungsanwendung wird zum Lesen der Daten verwendet🎜🎜🎜🎜Bei dieser IO-Methode gibt es ein großes Problem: Die Signalwarteschlange unter Linux ist begrenzt Daten können nicht gelesen werden 616161616161616161616161616161616161616161616161616161 61616161616161616161616161616161616c1616161616161616161616 "/> h Asynchron, nicht blockierend🎜🎜🎜Der asynchrone E/A-Prozess ist wie folgt: 🎜🎜🎜🎜🎜Wenn der Benutzerthread aio_read aufruft Beim Systemaufruf kann er sofort mit anderen Dingen beginnen und der Benutzerthread wird nicht blockiert 🎜🎜🎜🎜Der Kernel beginnt mit der ersten Phase von IO: der Datenvorbereitung. Wenn der Kernel wartet, bis die Daten bereit sind, kopiert er die Daten vom Kernel-Puffer in den Benutzerpuffer🎜🎜🎜🎜Der Kernel sendet ein Signal an den Benutzer-Thread oder ruft die vom Benutzer-Thread registrierte Rückrufschnittstelle zurück Sagen Sie dem Benutzer-Thread, dass der Lesevorgang abgeschlossen ist. 🎜
Nachdem der Benutzerprozess den Systemaufruf aio_read ausgeführt hat, werden die Kerneldaten unabhängig davon, ob sie bereit sind oder nicht, direkt an den Benutzerprozess zurückgegeben, und der Benutzermodusprozess kann dann andere Dinge tun . aio_read系统调用之后，无论内核数据是否准备好，都会直接返回给用户进程，然后用户态进程可以去做别的事情。
等到数据准备好了，内核直接复制数据给进程，然后从内核向进程发送通知。
对比信号驱动IO，异步IO的主要区别在于：
- 信号驱动由内核告诉我们何时可以开始一个IO操作(数据在内核缓冲区中)，而异步IO则由内核通知IO操作何时已经完成(数据已经在用户空间中)。
异步IO又叫做事件驱动IO，在Unix中，为异步方式访问文件定义了一套库函数，定义了AIO的一系列接口。
- 使用
aio_read或者aio_write发起异步IO操作，使用aio_error
Wenn die Daten bereit sind, kopiert der Kernel die Daten direkt in den Prozess und sendet dann eine Benachrichtigung vom Kernel an den Prozess.
Im Vergleich zu signalgesteuertem IO besteht der Hauptunterschied von asynchronem IO darin:
Das obige ist der detaillierte Inhalt vonWas bedeutet Linux IO?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!
