I/O 멀티플렉싱

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <sys/select.h>
#include <errno.h>

int main() {
    int server_fd, max_fd, client_fds[FD_SETSIZE];
    fd_set read_fds;
    struct sockaddr_in addr;
    char buffer[1024];
    int num_clients = 0;

    server_fd = socket(AF_INET, SOCK_STREAM, 0);
    if (server_fd < 0 || server_fd >= FD_SETSIZE) {
        fprintf(stderr, "server fd outside select range\n");
        if (server_fd >= 0) close(server_fd);
        return EXIT_FAILURE;
    }
    int opt = 1;
    setsockopt(server_fd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));

    memset(&addr, 0, sizeof(addr));
    addr.sin_family = AF_INET;
    addr.sin_addr.s_addr = INADDR_ANY;
    addr.sin_port = htons(8080);
    bind(server_fd, (struct sockaddr *)&addr, sizeof(addr));
    listen(server_fd, 128);

    while (1) {
        FD_ZERO(&read_fds);
        FD_SET(server_fd, &read_fds);
        max_fd = server_fd;

        for (int i = 0; i < num_clients; i++) {
            FD_SET(client_fds[i], &read_fds);
            if (client_fds[i] > max_fd) max_fd = client_fds[i];
        }

        int ready = select(max_fd + 1, &read_fds, NULL, NULL, NULL);
        if (ready < 0) {
            if (errno == EINTR) continue;
            perror("select failed");
            return EXIT_FAILURE;
        }

        // 새 연결 수락
        if (FD_ISSET(server_fd, &read_fds)) {
            int client_fd = accept(server_fd, NULL, NULL);
            if (client_fd >= 0) {
                if (client_fd >= FD_SETSIZE || num_clients >= FD_SETSIZE) {
                    close(client_fd);
                } else {
                    client_fds[num_clients++] = client_fd;
                }
            }
        }

        // 기존 클라이언트 처리
        for (int i = 0; i < num_clients; i++) {
            if (FD_ISSET(client_fds[i], &read_fds)) {
                ssize_t n = recv(client_fds[i], buffer, sizeof(buffer) - 1, 0);
                if (n <= 0) {
                    close(client_fds[i]);
                    client_fds[i] = client_fds[--num_clients];
                    i--;
                } else {
                    buffer[n] = '\0';
                    send(client_fds[i], buffer, n, 0);
                }
            }
        }
    }
}

struct pollfd fds[MAX_CLIENTS];
fds[0].fd = server_fd;
fds[0].events = POLLIN;

int nfds = 1;
int ret = poll(fds, nfds, -1);  // -1은 무한 대기

for (int i = 0; i < nfds; i++) {
    if (fds[i].revents & POLLIN) {
        // 이 소켓에서 읽을 데이터가 있음
    }
}

int epfd = epoll_create1(0);

struct epoll_event ev;
ev.events = EPOLLIN;
ev.data.fd = server_fd;
epoll_ctl(epfd, EPOLL_CTL_ADD, server_fd, &ev);

struct epoll_event events[MAX_EVENTS];
int n = epoll_wait(epfd, events, MAX_EVENTS, -1);

for (int i = 0; i < n; i++) {
    // events[i].data.fd에서 이벤트 발생
}

import selectors
import socket

sel = selectors.DefaultSelector()

def accept(server):
    client, addr = server.accept()
    client.setblocking(False)
    sel.register(client, selectors.EVENT_READ, data=echo)

def echo(client):
    data = client.recv(1024)
    if data:
        client.sendall(data)
    else:
        sel.unregister(client)
        client.close()

server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
server.bind(("0.0.0.0", 8080))
server.listen(128)
server.setblocking(False)
sel.register(server, selectors.EVENT_READ, data=accept)

# 이벤트 루프
while True:
    events = sel.select()
    for key, mask in events:
        callback = key.data
        callback(key.fileobj)

플랫폼과 빌드에 따라 달라지는 대표 구성

Nginx (C): epoll / kqueue
Node.js (JavaScript): libuv가 epoll / kqueue / IOCP 추상화
Redis (C): Linux에서는 epoll
Tornado (Python): 이벤트 루프의 플랫폼별 대기 구현 사용
asyncio (Python): Unix는 epoll / kqueue 등
  Windows 기본: ProactorEventLoop / IOCP
Netty (Java): epoll 전송 구현 / NIO 등

Node.js의 이벤트 루프:
  libuv가 플랫폼별 I/O를 처리
  JavaScript 코드가 콜백을 등록
  app.get("/", handler)는 Express의 경로 핸들러 등록 예
  요청은 HTTP 처리와 라우팅을 거쳐 handler에 전달