In a typical network server scenario, think about what each connected client is actually doing at any moment:

• A web browser fetches a page — then the user reads it for 30 seconds. The connection is idle.
• A chat client sends a message every few seconds. Between messages: idle.
• A database client executes a query — then waits for the application to process results. Idle.

If 99% of clients are idle at any given moment, dedicating an entire process or thread to each one is extremely wasteful. We have 500 sleeping processes burning memory, just waiting for data to arrive.

Linux provides three mechanisms, each an improvement over the previous:

select() takes a set of file descriptors and tells you which ones are ready for reading, writing, or have an error. You call it in a loop and process each ready fd.

#include <sys/select.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/socket.h>
#include <netinet/in.h>

#define PORT      9000
#define MAX_FDS   64
#define BUF_SIZE  1024

int main(void)
{
    int lfd, cfd;
    int clients[MAX_FDS];          /* Track connected client fds */
    int numClients = 0;
    struct sockaddr_in addr;
    fd_set readfds;
    int maxFd;

    /* Initialize client list */
    memset(clients, -1, sizeof(clients));

    /* Create listening socket */
    lfd = socket(AF_INET, SOCK_STREAM, 0);
    int opt = 1;
    setsockopt(lfd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));

    memset(&addr, 0, sizeof(addr));
    addr.sin_family      = AF_INET;
    addr.sin_port        = htons(PORT);
    addr.sin_addr.s_addr = htonl(INADDR_ANY);
    bind(lfd, (struct sockaddr *)&addr, sizeof(addr));
    listen(lfd, 10);

    printf("Single-process echo server on port %d\n", PORT);

    for (;;) {
        /*
         * Build the fd_set EVERY iteration.
         * select() modifies the set in place, so we must rebuild it.
         */
        FD_ZERO(&readfds);
        FD_SET(lfd, &readfds);   /* Always watch the listening socket */
        maxFd = lfd;

        /* Add all connected client sockets to the set */
        for (int i = 0; i < numClients; i++) {
            if (clients[i] != -1) {
                FD_SET(clients[i], &readfds);
                if (clients[i] > maxFd)
                    maxFd = clients[i];
            }
        }

        /*
         * select() blocks until at least one fd is ready.
         * Returns: number of ready fds, or -1 on error, 0 on timeout.
         * First arg: maxFd + 1 (must be one more than the highest fd).
         */
        int ready = select(maxFd + 1, &readfds, NULL, NULL, NULL);
        if (ready == -1) {
            perror("select");
            break;
        }

        /* Check if the listening socket has a new connection */
        if (FD_ISSET(lfd, &readfds)) {
            cfd = accept(lfd, NULL, NULL);
            if (cfd != -1 && numClients < MAX_FDS) {
                clients[numClients++] = cfd;
                printf("New client connected: fd=%d\n", cfd);
            }
        }

        /* Check each client socket for data */
        for (int i = 0; i < numClients; i++) {
            if (clients[i] == -1) continue;
            if (FD_ISSET(clients[i], &readfds)) {
                char buf[BUF_SIZE];
                ssize_t n = read(clients[i], buf, BUF_SIZE);
                if (n <= 0) {
                    /* n == 0: client disconnected; n == -1: error */
                    printf("Client fd=%d disconnected\n", clients[i]);
                    close(clients[i]);
                    clients[i] = -1;  /* Mark slot as free */
                } else {
                    /* Echo the data back */
                    write(clients[i], buf, n);
                }
            }
        }
    }

    return 0;
}

Limitation of select(): The maximum number of file descriptors in an fd_set is FD_SETSIZE, typically 1024 on Linux. Servers needing more than 1024 simultaneous connections must use poll() or epoll.

poll() works similarly to select() but uses an array of struct pollfd instead of bit sets. There is no hard limit on the number of file descriptors. However, it still scans the entire array on every call (O(n) per wakeup).

#include <poll.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/socket.h>
#include <netinet/in.h>

#define PORT     9000
#define BUF_SIZE 1024
#define MAX_FDS  1000

int main(void)
{
    struct pollfd fds[MAX_FDS];
    int nfds = 0;
    int lfd;
    struct sockaddr_in addr;

    lfd = socket(AF_INET, SOCK_STREAM, 0);
    int opt = 1;
    setsockopt(lfd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));

    memset(&addr, 0, sizeof(addr));
    addr.sin_family      = AF_INET;
    addr.sin_port        = htons(PORT);
    addr.sin_addr.s_addr = htonl(INADDR_ANY);
    bind(lfd, (struct sockaddr *)&addr, sizeof(addr));
    listen(lfd, 10);

    /* Add listening socket as first entry */
    fds[0].fd     = lfd;
    fds[0].events = POLLIN;
    nfds = 1;

    for (;;) {
        /*
         * poll() waits until at least one fd is ready.
         * Timeout -1 means wait forever.
         * After return, check fds[i].revents for what happened.
         */
        int ready = poll(fds, nfds, -1);
        if (ready == -1) {
            perror("poll");
            break;
        }

        /* Check listening socket */
        if (fds[0].revents & POLLIN) {
            int cfd = accept(lfd, NULL, NULL);
            if (cfd != -1 && nfds < MAX_FDS) {
                fds[nfds].fd     = cfd;
                fds[nfds].events = POLLIN;
                nfds++;
                printf("New client: fd=%d\n", cfd);
            }
        }

        /* Check each client */
        for (int i = 1; i < nfds; i++) {
            if (fds[i].revents & POLLIN) {
                char buf[BUF_SIZE];
                ssize_t n = read(fds[i].fd, buf, BUF_SIZE);
                if (n <= 0) {
                    close(fds[i].fd);
                    /* Remove by replacing with last entry */
                    fds[i] = fds[nfds - 1];
                    nfds--;
                    i--;
                } else {
                    write(fds[i].fd, buf, n);
                }
            }
        }
    }

    return 0;
}

epoll is Linux’s scalable I/O event notification mechanism. Unlike select() and poll() which scan ALL monitored fds on every wakeup, epoll returns ONLY the fds that are actually ready. This gives O(1) scaling per event — the performance does not degrade as the number of monitored fds grows.

#include <sys/epoll.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/socket.h>
#include <netinet/in.h>

#define PORT       9000
#define MAX_EVENTS 64
#define BUF_SIZE   1024

/* Make a socket non-blocking */
static void setNonBlocking(int fd)
{
    int flags = fcntl(fd, F_GETFL, 0);
    fcntl(fd, F_SETFL, flags | O_NONBLOCK);
}

int main(void)
{
    int lfd, epfd, cfd;
    struct sockaddr_in addr;
    struct epoll_event ev, events[MAX_EVENTS];

    /* 1. Create listening socket */
    lfd = socket(AF_INET, SOCK_STREAM, 0);
    int opt = 1;
    setsockopt(lfd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));

    memset(&addr, 0, sizeof(addr));
    addr.sin_family      = AF_INET;
    addr.sin_port        = htons(PORT);
    addr.sin_addr.s_addr = htonl(INADDR_ANY);
    bind(lfd, (struct sockaddr *)&addr, sizeof(addr));
    listen(lfd, SOMAXCONN);
    setNonBlocking(lfd);

    /* 2. Create the epoll instance */
    epfd = epoll_create1(0);
    if (epfd == -1) {
        perror("epoll_create1");
        exit(EXIT_FAILURE);
    }

    /* 3. Register the listening socket with epoll */
    ev.events  = EPOLLIN;      /* Notify when readable */
    ev.data.fd = lfd;
    if (epoll_ctl(epfd, EPOLL_CTL_ADD, lfd, &ev) == -1) {
        perror("epoll_ctl: lfd");
        exit(EXIT_FAILURE);
    }

    printf("epoll echo server listening on port %d\n", PORT);

    /* 4. Event loop */
    for (;;) {
        /*
         * epoll_wait() blocks until events are ready.
         * Returns: number of ready events in the events[] array.
         * Timeout -1: wait forever.
         */
        int nready = epoll_wait(epfd, events, MAX_EVENTS, -1);
        if (nready == -1) {
            perror("epoll_wait");
            break;
        }

        for (int i = 0; i < nready; i++) {
            if (events[i].data.fd == lfd) {
                /* New client connection */
                cfd = accept(lfd, NULL, NULL);
                if (cfd == -1) {
                    perror("accept");
                    continue;
                }
                setNonBlocking(cfd);

                /* Register the new client with epoll */
                ev.events  = EPOLLIN | EPOLLET;  /* Edge-triggered mode */
                ev.data.fd = cfd;
                epoll_ctl(epfd, EPOLL_CTL_ADD, cfd, &ev);
                printf("New client: fd=%d\n", cfd);

            } else {
                /* Data available from a client */
                char buf[BUF_SIZE];
                ssize_t n = read(events[i].data.fd, buf, BUF_SIZE);
                if (n <= 0) {
                    /* Client disconnected - remove from epoll and close */
                    epoll_ctl(epfd, EPOLL_CTL_DEL, events[i].data.fd, NULL);
                    close(events[i].data.fd);
                    printf("Client fd=%d disconnected\n", events[i].data.fd);
                } else {
                    write(events[i].data.fd, buf, n);
                }
            }
        }
    }

    close(lfd);
    close(epfd);
    return 0;
}

epoll supports two notification modes:

/* Edge-triggered: you MUST read all data in a loop when notified */
if (events[i].events & EPOLLIN) {
    char buf[1024];
    ssize_t n;
    /* Loop until EAGAIN = no more data right now */
    while ((n = read(fd, buf, sizeof(buf))) > 0) {
        write(fd, buf, n);  /* Echo back */
    }
    if (n == -1 && errno != EAGAIN) {
        /* Real error */
        perror("read");
        close(fd);
    }
    /* n == 0: client disconnected */
    /* n == -1 with EAGAIN: all data read, wait for next event */
}

When you have one process per client (fork model), the kernel’s scheduler ensures every client gets fair access to the CPU. Each process runs for a time slice, then the next one runs.

With a single-process event-driven design, you become the scheduler. If handling one client’s request takes a long time (for example, a slow disk read), ALL other clients wait because there is only one process. This is a critical difference:

This is why event-driven servers like Nginx use async I/O or worker threads for slow operations (like file reads), while using a single event loop for network I/O. Node.js solves this by making all I/O asynchronous and using libuv.

Besides I/O multiplexing, Linux also supports signal-driven I/O. Instead of calling select()/poll()/epoll_wait() to wait, the process sets up a signal handler for SIGIO and then the kernel delivers SIGIO whenever a file descriptor becomes ready. The process continues doing other work and is interrupted by the signal when I/O is ready.

/* Enable signal-driven I/O on a socket */
#include <fcntl.h>
#include <signal.h>

/* 1. Set the process to receive SIGIO for this fd */
fcntl(sockfd, F_SETOWN, getpid());

/* 2. Enable O_ASYNC flag */
int flags = fcntl(sockfd, F_GETFL, 0);
fcntl(sockfd, F_SETFL, flags | O_ASYNC | O_NONBLOCK);

/* 3. Install signal handler */
struct sigaction sa;
sa.sa_handler = io_handler;  /* Called when fd is ready */
sigemptyset(&sa.sa_mask);
sa.sa_flags = SA_RESTART;
sigaction(SIGIO, &sa, NULL);

Signal-driven I/O is rarely used in practice for servers because of the complexity of signal handlers and because epoll is more efficient and easier to use correctly. It is mentioned here for completeness.