Linux io fait référence à une opération sur un fichier ; sous Linux, un fichier est une série de flux binaires. Lors de l'échange d'informations, nous effectuons tous des opérations d'envoi et de réception de données sur ces flux. Ces opérations sont appelées opérations d'E/S. . Puisque Linux utilise un mécanisme de mémoire virtuelle, le noyau doit être demandé via des appels système pour terminer les opérations d'E/S.
L'environnement d'exploitation de ce tutoriel : système linux5.9.8, ordinateur Dell G3.
Que signifie Linux io ?
Nous savons tous que dans le monde Linux, tout est un fichier.
Et un fichier est une série de flux binaires, peu importe Socket, FIFO, pipe ou terminal, pour nous, tout est un flux.
Dans le processus d'échange d'informations, nous effectuons tous des opérations d'envoi et de réception de données sur ces flux, appelées opérations d'E/S.
Lisez les données du flux, le système appelle Read, écrit les données et le système appelle Write.
Habituellement, une IO complète du processus utilisateur est divisée en deux étapes :
E/S disque :
E/S réseau :
Le système d'exploitation et le pilote s'exécutent dans l'espace du noyau, et l'application fonctionnant dans l'espace utilisateur, les deux ne peuvent pas utiliser de pointeurs pour transférer des données, car le mécanisme de mémoire virtuelle utilisé par Linux doit demander au noyau via des appels système d'effectuer des actions d'E/S.
IO a trois types : IO mémoire, IO réseau et IO disque Habituellement, lorsque nous parlons d'IO, nous faisons référence aux deux derniers !
Pourquoi le modèle IO est nécessaire
Si vous utilisez synchrone pour communiquer, toutes les opérations seront exécutées séquentiellement dans un thread. Les inconvénients sont évidents :
Le modèle IO doit apparaître.
Avant de décrire le modèle Linux IO, comprenons d'abord le processus de lecture des données du système Linux :
Prenons l'exemple de l'utilisateur qui demande le fichier index.html
Espace utilisateur et espace noyau
Le cœur du système d'exploitation est le noyau, qui est indépendant des applications ordinaires et peut accéder à l'espace mémoire protégé et dispose également de toutes les autorisations pour accéder aux périphériques matériels sous-jacents.
Commutation de processus
Afin de contrôler l'exécution d'un processus, le noyau doit avoir la capacité de suspendre le processus en cours d'exécution sur le CPU et de reprendre l'exécution d'un processus précédemment suspendu.
Ce comportement est appelé changement de processus.
On peut donc dire que tout processus s'exécute avec le support du noyau du système d'exploitation et est étroitement lié au noyau.
Blocage du processus
Le processus en cours d'exécution, en raison de certains événements attendus qui ne se produisent pas, tels que l'échec de la demande de ressources système, l'attente de la fin d'une certaine opération, de nouvelles données qui ne sont pas encore arrivées ou aucun nouveau travail à effectuer, etc. ., sera bloqué par le système Exécuter automatiquement la primitive de blocage (Bloquer) pour passer de l'état d'exécution à l'état de blocage.
On voit que le blocage d'un processus est un comportement actif du processus lui-même, et donc seul un processus en état d'exécution (obtention du CPU) peut le transformer en état bloqué.
Lorsque le processus entre dans l'état de blocage, il n'occupe pas les ressources CPU.
Descripteur de fichier
Descripteur de fichier (Descripteur de fichier) est un terme en informatique et est un concept abstrait utilisé pour exprimer une référence à un fichier.
Le descripteur de fichier est formellement un entier non négatif. En fait, il s'agit d'une valeur d'index pointant vers la table d'enregistrement des fichiers ouverts par le processus maintenu par le noyau pour chaque processus.
E/S en cache
L'opération d'E/S par défaut pour la plupart des systèmes de fichiers est l'E/S en cache.
Le processus de lecture et d'écriture est le suivant :
Opération de lecture : Le système d'exploitation vérifie si le tampon du noyau contient les données requises. S'il a été mis en cache, il sera renvoyé directement depuis le cache, sinon il sera lu à partir du disque, de la carte réseau, etc. ., puis mis en cache dans le système d'exploitation Dans le cache ;
Opération d'écriture : Copier les données de l'espace utilisateur vers le cache dans l'espace noyau. À ce stade, l'opération d'écriture est terminée pour le programme utilisateur. Quant au moment d'écrire sur le disque, la carte réseau, etc., cela est déterminé par le système d'exploitation, à moins que la commande de synchronisation sync ne soit explicitement appelée.
En supposant qu'il n'y a pas de données requises dans le cache spatial du noyau, le processus utilisateur lit les données du disque ou du réseau en deux étapes :
Phase 1 : Le programme du noyau lit les données du disque, du réseau carte, etc. dans la zone de cache de l'espace noyau ;
Phase 2 : Le programme utilisateur copie les données du cache de l'espace noyau vers l'espace utilisateur.
Inconvénients des E/S mises en cache :
Les données doivent être copiées plusieurs fois dans l'espace d'adressage de l'application et dans l'espace du noyau pendant le processus de transmission. La surcharge du processeur et de la mémoire causée par ces opérations de copie de données est très importante.
L'application de l'espace utilisateur exécute un appel système, ce qui provoque le blocage de l'application et ne fait rien jusqu'à ce que les données soient prêtes, et les données sont copiées du noyau vers le processus utilisateur, et enfin le processus traite les données Dans les deux étapes d'attente des données et de traitement des données, l'ensemble du processus est bloqué et ne peut pas gérer les autres E/S du réseau.
C'est aussi le modèle IO le plus simple. Ce n'est pas un problème de l'utiliser lorsqu'il y a généralement peu de FD et que la préparation est rapide.
Après l'appel du système non bloquant, le processus n'est pas bloqué et le noyau revient immédiatement au processus. Si les données ne sont pas prêtes, une erreur sera renvoyée. temps.
Après le retour du processus, il peut faire autre chose avant de passer un appel système.
Répétez le processus ci-dessus et effectuez des appels système dans un cycle. Ce processus est souvent appelé sondage.
Interrogez et vérifiez les données du noyau jusqu'à ce que les données soient prêtes, puis copiez les données dans le processus pour le traitement des données.
Il convient de noter que pendant tout le processus de copie des données, le processus est toujours bloqué.
De cette façon, vous pouvez définir O_NONBLOCK sur le Socket en programmation. O_NONBLOCK即可。
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) }}首先我们允许Socket进行信号驱动IO，并安装一个信号处理函数，进程继续运行并不阻塞。
当数据准备好时，进程会收到一个SIGIO信号，可以在信号处理函数中调用I/O操作函数处理数据。
流程如下：
开启套接字信号驱动IO功能
系统调用Sigaction执行信号处理函数（非阻塞，立刻返回）
数据就绪，生成Sigio信号，通过信号回调通知应用来读取数据
此种IO方式存在的一个很大的问题：Linux中信号队列是有限制的，如果超过这个数字问题就无法读取数据
异步IO流程如下所示：
当用户线程调用了aio_read
Permet à un processus d'attendre une série d'événements.
Nous autorisons d'abord Socket à effectuer des IO pilotées par le signal et à installer une fonction de traitement du signal. Le processus continue de s'exécuter sans blocage. Lorsque les données sont prêtes, le processus recevra un signal SIGIO et pourra appeler la fonction d'opération d'E/S dans la fonction de traitement du signal pour traiter les données. 🎜🎜🎜Le processus est le suivant : 🎜🎜🎜🎜🎜Activer la fonction IO du pilote de signal de prise 🎜🎜🎜🎜Le système appelle Sigaction pour exécuter la fonction de traitement du signal (non bloquant, retour immédiat) 🎜🎜🎜🎜Les données sont prêt, générez le signal Sigio et transmettez le signal L'application de notification de rappel est utilisée pour lire les données🎜🎜🎜🎜Il y a un gros problème avec cette méthode IO : la file d'attente des signaux sous Linux est limitée si ce nombre est dépassé, les données. ne peut pas être lu🎜🎜h
Asynchrone non bloquant🎜🎜🎜Le processus d'E/S asynchrone est le suivant : 🎜🎜🎜🎜🎜Lorsque le thread utilisateur appelle le système
aio_readappel, il peut commencer à faire autre chose immédiatement et le thread utilisateur n'est pas bloqué 🎜🎜🎜🎜Le noyau commence la première phase des IO : préparer les données. Lorsque le noyau attend que les données soient prêtes, il copiera les données du tampon du noyau vers le tampon utilisateur🎜🎜🎜🎜Le noyau enverra un signal au thread utilisateur ou rappellera l'interface de rappel enregistrée par le thread utilisateur pour dire au thread utilisateur L'opération de lecture est terminée🎜🎜🎜🎜Le thread utilisateur lit les données dans le tampon utilisateur et termine les opérations commerciales ultérieures🎜🎜🎜🎜🎜Par rapport aux IO synchrones, les IO asynchrones ne sont pas exécutées séquentiellement. 🎜
Une fois que le processus utilisateur a effectué l'appel système aio_read, que les données du noyau soient prêtes ou non, elles seront renvoyées directement au processus utilisateur, puis le processus en mode utilisateur pourra faire d'autres choses. . aio_read系统调用之后，无论内核数据是否准备好，都会直接返回给用户进程，然后用户态进程可以去做别的事情。
等到数据准备好了，内核直接复制数据给进程，然后从内核向进程发送通知。
对比信号驱动IO，异步IO的主要区别在于：
异步IO又叫做事件驱动IO，在Unix中，为异步方式访问文件定义了一套库函数，定义了AIO的一系列接口。
aio_read或者aio_write发起异步IO操作，使用aio_error
Par rapport aux IO pilotées par signal, la principale différence entre les IO asynchrones est :
Les IO asynchrones sont également appelées IO pilotées par événements Sous Unix, un ensemble de fonctions de bibliothèque sont définies pour l'accès asynchrone aux fichiers, et une série d'interfaces AIO sont définies. 
aio_read ou aio_write pour lancer une opération d'E/S asynchrone et utilisez aio_error pour vérifier l'état de l'E/S en cours d'exécution. opération. Il existe actuellement de nombreuses bibliothèques d'E/S asynchrones open source, telles que libevent, libev et libuv. Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!
![[Introduction aux débutants, facile à comprendre] Apprenez Linux en une semaine](https://img.php.cn/upload/course/000/000/068/6242a86a890b1568.png)
![Cours de base sur l'exploitation et la maintenance de Linux [explication détaillée de l'ensemble du processus]](https://img.php.cn/upload/course/000/000/068/63ff173c79edd672.jpg)
![[Web front-end] Démarrage rapide de Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
