Artikelverzeichnis
Überblick
Wenn es um den ET-Modus (Edge Trigger) und den LT-Modus (Level Trigger) in der Linux-Netzwerkprogrammierung geht, müssen wir ihre Rollen und Unterschiede in der ereignisgesteuerten Programmierung verstehen. Nachfolgend finden Sie einen Blog-Beitrag, in dem beide Modi ausführlich erläutert werden, einschließlich Codebeispielen.
Zusammenfassung
Zusammenfassung: In der Linux-Netzwerkprogrammierung sind der ET-Modus (Flankentrigger) und der LT-Modus (Pegeltrigger) zwei häufig verwendete Ereignistriggermethoden. In diesem Artikel werden die Prinzipien und Verwendungsszenarien dieser beiden Modi ausführlich vorgestellt und entsprechende Codebeispiele bereitgestellt, um den Lesern zu helfen, sie besser zu verstehen und anzuwenden.
Text:
einführen
Bei der ereignisgesteuerten Programmierung bestimmt die Art und Weise, wie Ereignisse ausgelöst werden, wann und wie die Anwendung über eingetretene Ereignisse benachrichtigt wird. Der ET-Modus und der LT-Modus sind zwei gängige ereignisgesteuerte Methoden, die hauptsächlich zur Verarbeitung nicht blockierender E/A-Vorgänge verwendet werden.
Es gibt zwei Modelle von EPOLL-Ereignissen:
Edge Triggered (ET): Edge Triggering wird nur ausgelöst, wenn Daten eintreffen, unabhängig davon, ob sich noch Daten im Puffer befinden.
Level Triggered (LT): Der Level Trigger wird ausgelöst, solange Daten vorhanden sind.
ET-Modus (Flankentrigger)
ET (flankengesteuert): ET ist ein Hochgeschwindigkeits-Arbeitsmodus und unterstützt nur No-Block-Socket . In diesem Modus teilt Ihnen der Kernel über Epoll mit, wann ein Deskriptor von „bereit“ auf „bereit“ wechselt. Es geht dann davon aus, dass Sie wissen, dass der Dateideskriptor bereit ist, und sendet keine weiteren Bereitschaftsbenachrichtigungen für diesen Dateideskriptor. Bitte beachten Sie, dass der Kernel keine weiteren Benachrichtigungen sendet (nur einmal), wenn der E/A-Vorgang auf diesem fd nicht ausgeführt wurde (was dazu führt, dass er wieder nicht bereit ist).
Das Folgende ist ein Beispielcode-Snippet im ET-Modus, der epoll verwendet, um einen Socket abzuhören und Daten zu lesen:
/* server.c */
#include <stdio.h>
#include <string.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <sys/wait.h>
#include <sys/types.h>
#include <sys/epoll.h>
#include <unistd.h>
#include <fcntl.h>
#define MAXLINE 10
#define SERV_PORT 8080
int main(void)
{
struct sockaddr_in servaddr, cliaddr;
socklen_t cliaddr_len;
int listenfd, connfd;
char buf[MAXLINE];
char str[INET_ADDRSTRLEN];
int i, efd, flag;
listenfd = socket(AF_INET, SOCK_STREAM, 0);
bzero(&servaddr, sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
servaddr.sin_port = htons(SERV_PORT);
bind(listenfd, (struct sockaddr *)&servaddr, sizeof(servaddr));
listen(listenfd, 20);
struct epoll_event event;
struct epoll_event resevent[10];
int res, len;
efd = epoll_create(10);
/* event.events = EPOLLIN; */
event.events = EPOLLIN | EPOLLET; /* ET 边沿触发 ，默认是水平触发 */
printf("Accepting connections ...\n");
cliaddr_len = sizeof(cliaddr);
connfd = accept(listenfd, (struct sockaddr *)&cliaddr, &cliaddr_len);
printf("received from %s at PORT %d\n",
inet_ntop(AF_INET, &cliaddr.sin_addr, str, sizeof(str)),
ntohs(cliaddr.sin_port));
flag = fcntl(connfd, F_GETFL);//将其转化为no-block
flag |= O_NONBLOCK;
fcntl(connfd, F_SETFL, flag);
event.data.fd = connfd;
epoll_ctl(efd, EPOLL_CTL_ADD, connfd, &event);
while (1) {
printf("epoll_wait begin\n");
res = epoll_wait(efd, resevent, 10, -1);
printf("epoll_wait end res %d\n", res);
if (resevent[0].data.fd == connfd) {
while ((len = read(connfd, buf, MAXLINE/2)) > 0)
write(STDOUT_FILENO, buf, len);
}
}
return 0;
}
LT-Modus (Level-Trigger-Standard)
Der LT-Modus benachrichtigt so lange, wenn das Ereignis auftritt, bis die Anwendung das Ereignis verarbeitet. Die Anwendung muss nicht ständig Daten lesen oder schreiben und kann in jeder Ereignisbenachrichtigung nur einen Teil der Daten verarbeiten. Der LT-Modus eignet sich für Szenarien, die eine bedarfsgesteuerte Datenverarbeitung erfordern, z. B. Batch-Datenverarbeitung und Dateiübertragung.
Unten finden Sie ein Beispielcode-Snippet im LT-Modus, das epoll verwendet, um einen Socket abzuhören und Daten zu lesen:
// 创建epoll实例
int epollfd = epoll_create1(0);
// 添加监听套接字到epoll实例
struct epoll_event ev;
ev.events = EPOLLIN; // LT模式
ev.data.fd = sockfd;
epoll_ctl(epollfd, EPOLL_CTL_ADD, sockfd, &ev);
// 循环监听事件并处理
while (1) {
struct epoll_event events[MAX_EVENTS];
int ready = epoll_wait(epollfd, events, MAX_EVENTS, -1);
for (int i = 0; i < ready; i++) {
if (events[i].events & EPOLLIN) {
// 读取数据
char buffer[READ_SIZE];
int bytesRead = read(events[i].data.fd, buffer, READ_SIZE);
// 处理数据
// ...
}
}
}
Zusammenfassen
Der ET-Modus und der LT-Modus sind häufig verwendete Methoden zur Ereignisauslösung in der Linux-Netzwerkprogrammierung. Der ET-Modus erfordert, dass die Anwendung beim Lesen oder Schreiben von Daten immer ausgeführt wird, und eignet sich für Szenarien, in denen alle Daten zeitnah verarbeitet werden müssen. Der LT-Modus ermöglicht Anwendungen die Verarbeitung von Daten bei Bedarf und eignet sich für Szenarien, in denen Daten bei Bedarf verarbeitet werden müssen. Das Verständnis und die richtige Anwendung dieser beiden Muster ist für die Entwicklung effizienter und zuverlässiger Webanwendungen von entscheidender Bedeutung.
Wir hoffen, dass die Leser durch die oben aufgeführten detaillierten Erläuterungen und Codebeispiele die Rolle und den Unterschied zwischen dem ET-Modus und dem LT-Modus bei der Linux-Netzwerkprogrammierung besser verstehen können. Die Wahl dieser beiden Modi hängt von den spezifischen Anwendungsanforderungen ab, und der Entwickler kann entsprechend der tatsächlichen Situation entscheiden, welchen Modus er verwenden möchte.
Ich hoffe, dieser Artikel war hilfreich für Sie. Wenn Sie noch Fragen haben, können Sie diese gerne stellen!