MENU
  1. ホーム
  2. C 언어
  3. C언어로 다중 소켓 처리: select 함수 활용 방법

C언어로 다중 소켓 처리: select 함수 활용 방법

C 언어

C언어에서 다중 소켓을 처리하는 것은 네트워크 프로그래밍에서 필수적인 기술입니다. 특히 select 함수는 여러 소켓의 상태를 동시에 감지하고 관리할 수 있는 강력한 도구로, 비동기 처리와 효율적인 자원 활용을 가능하게 합니다. 본 기사에서는 select 함수의 기초 개념부터 실제 코드 예제와 응용 방법까지 단계별로 살펴보며, 네트워크 프로그래밍 초보자부터 숙련자까지 유용하게 활용할 수 있는 정보를 제공합니다.

목차

select 함수란 무엇인가


select 함수는 네트워크 프로그래밍에서 다중 소켓을 효율적으로 관리하기 위해 사용되는 시스템 콜입니다. 이 함수는 소켓이 읽기, 쓰기, 또는 예외 상태가 가능한지 확인하여 개발자가 특정 이벤트에 응답할 수 있도록 합니다.

select 함수의 정의


select는 POSIX 표준에 포함된 함수로, 소켓, 파일 디스크립터 또는 다른 스트림의 상태를 모니터링합니다. 이를 통해 하나의 스레드로 여러 소켓을 처리할 수 있어 비동기적이고 효율적인 네트워크 애플리케이션을 구현할 수 있습니다.

select 함수의 주요 특징

  • 비차단형 모니터링: 여러 소켓을 동시에 감지하며, 특정 조건이 충족될 때만 제어를 반환합니다.
  • 광범위한 지원: 대부분의 유닉스 계열 시스템과 C 기반 네트워크 라이브러리에서 지원됩니다.
  • 유연성: 읽기, 쓰기, 예외 상황을 개별적으로 모니터링할 수 있습니다.

select 함수의 장점과 단점

  • 장점:
  • 단일 스레드에서 다중 소켓 관리 가능
  • 널리 사용되며 안정적인 구현
  • 단점:
  • 소켓 수가 많아지면 성능 저하 가능
  • 매번 소켓 리스트를 재구성해야 하는 오버헤드 발생

select 함수는 C언어 기반 네트워크 프로그래밍의 기본 요소로, 다중 소켓 처리를 이해하기 위한 출발점이라 할 수 있습니다.

다중 소켓 처리의 개념


다중 소켓 처리는 네트워크 프로그래밍에서 여러 클라이언트나 데이터 스트림을 동시에 관리하기 위한 기술입니다. 이는 대규모 연결을 효율적으로 처리하고 자원을 최적화하는 데 필수적입니다.

다중 소켓 처리의 필요성


서버 애플리케이션은 여러 클라이언트의 요청을 동시에 처리해야 하는 경우가 많습니다. 단일 소켓으로는 이러한 요구를 충족할 수 없으므로, 다중 소켓을 사용하여 효율성을 높이고 응답성을 보장해야 합니다.

  • 예시: 채팅 서버, 파일 업로드 서버, 게임 서버 등은 다수의 클라이언트를 동시에 관리해야 합니다.

다중 소켓 처리를 위한 접근 방식

  • 스레드 기반: 각 소켓에 대해 개별 스레드를 생성하여 처리.
  • 장점: 간단한 설계, 병렬 처리 가능.
  • 단점: 많은 스레드로 인해 메모리 사용량 증가 및 컨텍스트 스위칭 오버헤드.
  • 비동기 I/O: 이벤트 기반 방식으로 소켓 상태를 모니터링하여 필요 시 처리.
  • 장점: 자원 효율성, 높은 동시성.
  • 단점: 구현 복잡성 증가.

select를 활용한 다중 소켓 처리


select 함수는 비동기 I/O 방식을 활용하여 다중 소켓을 효율적으로 관리할 수 있습니다. 이를 통해 특정 소켓의 상태 변화(예: 데이터 읽기 가능, 쓰기 가능)를 감지하고 적절한 작업을 수행할 수 있습니다.

  • 읽기 이벤트: 클라이언트가 데이터를 전송한 경우 처리.
  • 쓰기 이벤트: 클라이언트로 데이터를 전송할 준비가 된 경우 처리.
  • 예외 이벤트: 소켓에서 오류가 발생한 경우 처리.

다중 소켓 처리는 네트워크 애플리케이션의 성능과 안정성을 결정짓는 핵심 기술입니다. select는 이를 구현하는 대표적인 방법으로, 대규모 연결을 처리하는 데 강력한 도구가 됩니다.

select 함수의 주요 파라미터


select 함수는 네트워크 프로그래밍에서 소켓 상태를 감지하기 위해 사용되며, 주요 파라미터를 통해 다양한 동작을 제어합니다. 이 섹션에서는 select 함수의 인자와 역할을 상세히 설명합니다.

select 함수의 기본 구조

int select(int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout);

각 파라미터의 역할

  • nfds
  • 감시할 파일 디스크립터의 범위를 지정합니다.
  • 가장 큰 파일 디스크립터 값에 1을 더한 값으로 설정해야 합니다.
  • 예: 만약 감시하려는 파일 디스크립터가 0, 1, 4라면 nfds = 5로 설정.
  • readfds
  • 읽기 이벤트를 감지할 소켓 목록을 설정합니다.
  • 소켓에서 데이터가 수신 가능할 때 감지됩니다.
  • 설정 및 초기화: FD_SET() 및 FD_ZERO() 함수 사용.
  • writefds
  • 쓰기 이벤트를 감지할 소켓 목록을 설정합니다.
  • 소켓이 데이터를 전송할 준비가 된 경우 감지됩니다.
  • exceptfds
  • 예외 이벤트(오류 상태)를 감지할 소켓 목록을 설정합니다.
  • 예를 들어, 연결 해제나 비정상 종료 상황을 감지할 때 사용됩니다.
  • timeout
  • 대기 시간 제한을 설정합니다.
  • struct timeval 구조체를 사용하며, 초(tv_sec)와 마이크로초(tv_usec) 단위로 지정.
  • 값이 NULL이면 무한 대기, 값이 0이면 즉시 반환.

파일 디스크립터 설정 함수

  • FD_SET(fd, fd_set*): 파일 디스크립터를 지정된 집합에 추가.
  • FD_CLR(fd, fd_set*): 파일 디스크립터를 지정된 집합에서 제거.
  • FD_ISSET(fd, fd_set*): 파일 디스크립터가 지정된 집합에 포함되어 있는지 확인.
  • FD_ZERO(fd_set*): 파일 디스크립터 집합을 초기화.

예시: 파라미터 설정

fd_set readfds;
FD_ZERO(&readfds);
FD_SET(socket_fd, &readfds);

struct timeval timeout;
timeout.tv_sec = 5;
timeout.tv_usec = 0;

int result = select(socket_fd + 1, &readfds, NULL, NULL, &timeout);
if (result > 0 && FD_ISSET(socket_fd, &readfds)) {
    printf("Data available to read.\n");
}

요약


select 함수의 주요 파라미터는 다중 소켓의 상태를 효율적으로 모니터링하는 데 핵심적인 역할을 합니다. 적절한 파라미터 설정은 select의 효과적인 사용을 보장합니다.

select 함수의 동작 과정


select 함수는 소켓 상태를 감지하여 이벤트가 발생했을 때 제어를 반환합니다. 이 섹션에서는 select 함수의 동작 과정을 단계별로 설명합니다.

1. 파일 디스크립터 준비


select 함수는 파일 디스크립터를 감시하기 위해 준비된 집합을 사용합니다.

  • FD_ZERO를 사용하여 파일 디스크립터 집합 초기화.
  • FD_SET로 감시 대상 소켓을 집합에 추가.

예:

fd_set readfds;
FD_ZERO(&readfds);
FD_SET(socket_fd, &readfds);

2. 감시 범위 설정


select는 nfds 값을 통해 감시할 파일 디스크립터의 최대값을 설정합니다.

  • 예: 소켓 파일 디스크립터 값이 4라면 nfds는 5로 설정.

3. 대기


select 함수는 입력된 파일 디스크립터 집합에 대해 상태 변화를 대기합니다.

  • 상태 변화:
  • 읽기 가능(데이터 수신 가능)
  • 쓰기 가능(데이터 전송 가능)
  • 예외 발생(소켓 오류)
  • 대기 시간은 timeout 값에 따라 결정됩니다.
  • NULL: 무한 대기.
  • 0: 즉시 반환.
  • 특정 값: 지정된 시간만큼 대기.

4. 반환값 처리


select 함수는 상태 변화를 감지하면 즉시 반환하며, 반환값은 다음과 같습니다:

  • >0: 상태 변화가 발생한 파일 디스크립터의 개수.
  • 0: 대기 시간 초과(타임아웃).
  • <0: 오류 발생.

5. 상태 확인 및 처리


반환된 집합을 통해 소켓의 상태를 확인하고 적절한 작업을 수행합니다.

  • FD_ISSET를 사용하여 특정 소켓의 상태 확인.

예:

if (FD_ISSET(socket_fd, &readfds)) {
    // 읽기 가능 상태에서 데이터 처리
    recv(socket_fd, buffer, sizeof(buffer), 0);
}

예제 코드: 전체 동작 과정

fd_set readfds;
FD_ZERO(&readfds);
FD_SET(socket_fd, &readfds);

struct timeval timeout;
timeout.tv_sec = 5;
timeout.tv_usec = 0;

int result = select(socket_fd + 1, &readfds, NULL, NULL, &timeout);
if (result > 0) {
    if (FD_ISSET(socket_fd, &readfds)) {
        char buffer[1024];
        recv(socket_fd, buffer, sizeof(buffer), 0);
        printf("Received: %s\n", buffer);
    }
} else if (result == 0) {
    printf("Timeout occurred.\n");
} else {
    perror("select error");
}

요약


select 함수는 파일 디스크립터를 감시하고 상태 변화를 감지하면 제어를 반환합니다. 이를 통해 비동기적으로 다중 소켓을 처리할 수 있습니다. 적절한 파일 디스크립터 설정과 반환값 처리가 select 함수의 효율적인 활용을 보장합니다.

기본 코드 예제


select 함수는 간단한 설정으로 다중 소켓을 관리할 수 있습니다. 이 섹션에서는 select를 활용한 기본적인 다중 소켓 처리 코드 예제를 설명합니다.

예제: 단일 클라이언트 연결 감지


아래 코드는 서버 소켓에서 클라이언트 연결 요청을 감지하고 데이터를 처리하는 예제입니다.

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

#define PORT 8080
#define BUFFER_SIZE 1024

int main() {
    int server_fd, client_fd, max_fd;
    struct sockaddr_in server_addr, client_addr;
    fd_set readfds;
    char buffer[BUFFER_SIZE];
    socklen_t addr_len = sizeof(client_addr);

    // 1. 서버 소켓 생성
    server_fd = socket(AF_INET, SOCK_STREAM, 0);
    if (server_fd == -1) {
        perror("Socket creation failed");
        exit(EXIT_FAILURE);
    }

    // 2. 서버 주소 설정
    server_addr.sin_family = AF_INET;
    server_addr.sin_addr.s_addr = INADDR_ANY;
    server_addr.sin_port = htons(PORT);

    // 3. 소켓 바인딩
    if (bind(server_fd, (struct sockaddr*)&server_addr, sizeof(server_addr)) == -1) {
        perror("Bind failed");
        close(server_fd);
        exit(EXIT_FAILURE);
    }

    // 4. 소켓 리스닝
    if (listen(server_fd, 5) == -1) {
        perror("Listen failed");
        close(server_fd);
        exit(EXIT_FAILURE);
    }

    printf("Server listening on port %d\n", PORT);

    // 5. select 설정 및 대기
    while (1) {
        FD_ZERO(&readfds);
        FD_SET(server_fd, &readfds);
        max_fd = server_fd;

        // select 호출
        int activity = select(max_fd + 1, &readfds, NULL, NULL, NULL);
        if (activity < 0) {
            perror("select error");
            break;
        }

        // 6. 클라이언트 연결 요청 처리
        if (FD_ISSET(server_fd, &readfds)) {
            client_fd = accept(server_fd, (struct sockaddr*)&client_addr, &addr_len);
            if (client_fd < 0) {
                perror("Accept failed");
                continue;
            }
            printf("Client connected.\n");

            // 데이터 수신
            int bytes_received = recv(client_fd, buffer, BUFFER_SIZE, 0);
            if (bytes_received > 0) {
                buffer[bytes_received] = '\0';
                printf("Received: %s\n", buffer);

                // 데이터 전송
                send(client_fd, "Message received", 16, 0);
            }
            close(client_fd);
        }
    }

    close(server_fd);
    return 0;
}

코드 설명

  1. 소켓 생성 및 설정: 서버 소켓을 생성하고 주소를 설정합니다.
  2. 바인딩 및 리스닝: 서버 소켓을 특정 포트에 바인딩하고 클라이언트 연결을 대기합니다.
  3. select 호출: readfds를 설정하여 소켓 상태 변화를 감지합니다.
  4. 클라이언트 처리: 클라이언트 연결을 수락하고 데이터를 송수신합니다.

실행 결과

  • 서버가 실행되면 지정된 포트에서 클라이언트 연결 요청을 감지합니다.
  • 클라이언트가 데이터를 전송하면 서버는 이를 출력하고 응답 메시지를 전송합니다.

요약


이 예제는 select 함수의 기본 사용법을 보여주며, 다중 소켓 처리를 위한 시작점입니다. 이를 확장하면 여러 클라이언트와의 동시 연결 및 데이터 처리가 가능합니다.

성능 최적화 방법


select 함수는 다중 소켓 처리를 위한 강력한 도구지만, 소켓 수가 많아질수록 성능 문제가 발생할 수 있습니다. 이 섹션에서는 select 함수의 성능을 최적화하기 위한 몇 가지 방법을 소개합니다.

1. 파일 디스크립터 범위 최소화

  • select 함수는 nfds 값에 따라 파일 디스크립터를 순차적으로 확인합니다.
  • 불필요하게 큰 nfds 값을 설정하면 불필요한 검사가 증가하여 성능이 저하됩니다.
  • 해결 방법:
  • 항상 nfds를 가장 큰 파일 디스크립터 값에 1을 더한 값으로 설정합니다.

예

int max_fd = socket_fd > client_fd ? socket_fd : client_fd;
select(max_fd + 1, &readfds, NULL, NULL, NULL);

2. 동적 파일 디스크립터 관리

  • 모든 소켓을 매번 집합에 추가하면 오버헤드가 발생합니다.
  • 해결 방법:
  • 활성 상태의 소켓만 집합에 추가하여 처리합니다.
  • 불필요한 소켓은 FD_CLR로 제거합니다.

예

if (!is_active(socket_fd)) {
    FD_CLR(socket_fd, &readfds);
}

3. 타임아웃 설정

  • select 함수가 무기한 대기하지 않도록 적절한 타임아웃 값을 설정합니다.
  • 타임아웃을 활용하면 시스템 리소스를 효율적으로 관리할 수 있습니다.
  • 해결 방법:
  • 적합한 대기 시간 값을 struct timeval에 설정합니다.

예

struct timeval timeout;
timeout.tv_sec = 2;
timeout.tv_usec = 500000;  // 2.5초 대기
select(max_fd + 1, &readfds, NULL, NULL, &timeout);

4. 멀티플렉싱 방식 전환

  • 소켓 수가 매우 많아 select의 성능이 제한된다면 다른 멀티플렉싱 방식을 고려합니다.
  • 대안:
  • poll: 동적 파일 디스크립터 관리 가능.
  • epoll (리눅스): 대규모 소켓 처리에 적합.

예: epoll 사용

int epoll_fd = epoll_create(1);
struct epoll_event event;
event.events = EPOLLIN;
event.data.fd = socket_fd;
epoll_ctl(epoll_fd, EPOLL_CTL_ADD, socket_fd, &event);

5. 메모리 사용 최적화

  • 소켓 상태 변경 감지를 위한 파일 디스크립터 집합 초기화 및 복제 과정에서 불필요한 메모리 할당을 방지합니다.
  • 해결 방법:
  • 반복 사용되는 fd_set 변수는 재활용합니다.
  • 필요할 때만 FD_ZERO로 초기화.

6. 비동기 I/O와 결합

  • select를 비동기 I/O와 결합하면 대기 시간을 줄이고 응답 속도를 높일 수 있습니다.
  • 예: fcntl로 소켓을 논블로킹 모드로 설정.

예

int flags = fcntl(socket_fd, F_GETFL, 0);
fcntl(socket_fd, F_SETFL, flags | O_NONBLOCK);

요약


select 함수의 성능 최적화는 파일 디스크립터 관리, 타임아웃 설정, 그리고 대체 멀티플렉싱 기법 도입을 통해 이루어질 수 있습니다. 이러한 최적화 기법을 활용하면 대규모 네트워크 애플리케이션에서도 효율적으로 동작할 수 있습니다.

일반적인 오류와 디버깅


select 함수는 다중 소켓 처리를 효과적으로 수행하지만, 사용 과정에서 발생할 수 있는 일반적인 오류와 이를 해결하기 위한 디버깅 방법을 이해하는 것이 중요합니다.

1. 잘못된 파일 디스크립터

  • 문제: select에 전달된 파일 디스크립터가 유효하지 않은 경우 오류가 발생합니다.
  • 증상: select가 -1을 반환하고 errno 값이 EBADF로 설정됩니다.
  • 해결 방법:
  • 파일 디스크립터가 유효한지 확인합니다.
  • 닫힌 소켓이 파일 디스크립터 집합에 포함되지 않도록 합니다.

디버깅 코드

if (FD_ISSET(socket_fd, &readfds) && fcntl(socket_fd, F_GETFD) == -1) {
    perror("Invalid file descriptor");
}

2. 타임아웃 설정 문제

  • 문제: 타임아웃 값을 설정하지 않거나, 잘못된 구조체를 전달하는 경우.
  • 증상:
  • select가 무한 대기 상태에 빠지거나, 즉시 반환합니다.
  • 해결 방법:
  • struct timeval을 올바르게 설정합니다.
  • 타임아웃 값을 명확히 정의합니다.

타임아웃 설정 예

struct timeval timeout;
timeout.tv_sec = 5;  // 5초 대기
timeout.tv_usec = 0;

3. 파일 디스크립터 집합 초기화 누락

  • 문제: FD_ZERO로 집합을 초기화하지 않고 사용하면 예기치 않은 동작이 발생합니다.
  • 증상:
  • select가 항상 0을 반환하거나 특정 이벤트를 감지하지 못함.
  • 해결 방법:
  • 각 루프 시작 시 FD_ZERO로 집합을 초기화합니다.

코드 예시

FD_ZERO(&readfds);
FD_SET(socket_fd, &readfds);

4. 소켓 상태 확인 누락

  • 문제: FD_ISSET로 상태를 확인하지 않고 데이터 처리 시 오류 발생.
  • 증상:
  • 잘못된 소켓에서 데이터 읽기 또는 쓰기 시 프로그램 충돌.
  • 해결 방법:
  • 반환된 파일 디스크립터 집합에서 소켓 상태를 항상 확인합니다.

예

if (FD_ISSET(socket_fd, &readfds)) {
    recv(socket_fd, buffer, sizeof(buffer), 0);
}

5. 연결 해제 시 처리 누락

  • 문제: 클라이언트가 연결을 종료해도 소켓을 닫지 않아 리소스 누수가 발생.
  • 증상:
  • 소켓의 데이터 수신이 중단되며, 리소스 사용량 증가.
  • 해결 방법:
  • 소켓에서 데이터가 0 바이트 반환되면 연결이 종료된 것으로 간주하고 소켓을 닫습니다.

코드 예시

int bytes_received = recv(socket_fd, buffer, sizeof(buffer), 0);
if (bytes_received == 0) {
    printf("Client disconnected\n");
    close(socket_fd);
    FD_CLR(socket_fd, &readfds);
}

6. 오류 발생 시 디버깅 도구 활용

  • 문제 해결: select 관련 문제를 디버깅할 때 아래 도구를 활용합니다.
  • strace: 시스템 호출 추적.
  • gdb: 런타임 디버깅.
  • 로그 파일: 각 단계에서 상태 기록.

로그 예시

fprintf(log_file, "File descriptor %d is ready for reading.\n", socket_fd);

요약


select 함수 사용 중 발생할 수 있는 일반적인 오류는 파일 디스크립터 관리, 타임아웃 설정, 및 상태 확인과 관련이 있습니다. 올바른 설정과 디버깅 도구 활용을 통해 문제를 해결하고 안정적인 다중 소켓 처리를 구현할 수 있습니다.

응용 사례와 실습 예제


select 함수는 다양한 네트워크 애플리케이션에서 활용됩니다. 이 섹션에서는 실제 응용 사례를 소개하고, 실습을 통해 이해를 심화할 수 있는 예제를 제공합니다.

응용 사례

1. 채팅 서버

  • 설명: 다수의 클라이언트로부터 메시지를 수신하고 이를 다른 클라이언트에게 전달하는 서버.
  • 특징:
  • 다중 클라이언트 소켓 처리.
  • 비동기 데이터 송수신.
  • 활용: 메신저 애플리케이션, 실시간 협업 도구.

2. 멀티플렉스 HTTP 서버

  • 설명: 클라이언트로부터 HTTP 요청을 수신하고 비동기적으로 응답하는 서버.
  • 특징:
  • 비차단 I/O 방식으로 요청 처리.
  • 리소스 효율적 관리.
  • 활용: 간단한 웹 서버, API 서버.

3. 게임 서버

  • 설명: 실시간 멀티플레이어 게임에서 다수의 플레이어 데이터를 동시 처리.
  • 특징:
  • 소켓 상태 감지와 빠른 응답 속도 필요.
  • 예외 처리 및 오류 복구 기능.
  • 활용: MMO 게임, 모바일 게임 서버.

실습 예제

예제 1: 멀티 클라이언트 채팅 서버


아래 코드는 select를 활용하여 다수의 클라이언트 메시지를 처리하는 채팅 서버의 간단한 구현입니다.

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <unistd.h>
#include <arpa/inet.h>

#define PORT 8080
#define MAX_CLIENTS 10
#define BUFFER_SIZE 1024

int main() {
    int server_fd, client_fd, max_fd, activity, i, new_socket;
    int client_sockets[MAX_CLIENTS] = {0};
    struct sockaddr_in server_addr, client_addr;
    socklen_t addr_len = sizeof(client_addr);
    fd_set readfds;
    char buffer[BUFFER_SIZE];

    // 1. 서버 소켓 생성
    server_fd = socket(AF_INET, SOCK_STREAM, 0);
    if (server_fd == -1) {
        perror("Socket creation failed");
        exit(EXIT_FAILURE);
    }

    server_addr.sin_family = AF_INET;
    server_addr.sin_addr.s_addr = INADDR_ANY;
    server_addr.sin_port = htons(PORT);

    // 2. 소켓 바인딩 및 리스닝
    bind(server_fd, (struct sockaddr*)&server_addr, sizeof(server_addr));
    listen(server_fd, 5);

    printf("Server listening on port %d\n", PORT);

    while (1) {
        // 3. 파일 디스크립터 집합 초기화
        FD_ZERO(&readfds);
        FD_SET(server_fd, &readfds);
        max_fd = server_fd;

        for (i = 0; i < MAX_CLIENTS; i++) {
            if (client_sockets[i] > 0) {
                FD_SET(client_sockets[i], &readfds);
                if (client_sockets[i] > max_fd)
                    max_fd = client_sockets[i];
            }
        }

        // 4. select 호출
        activity = select(max_fd + 1, &readfds, NULL, NULL, NULL);
        if (activity < 0) {
            perror("Select error");
            continue;
        }

        // 5. 새 클라이언트 연결 처리
        if (FD_ISSET(server_fd, &readfds)) {
            new_socket = accept(server_fd, (struct sockaddr*)&client_addr, &addr_len);
            if (new_socket >= 0) {
                printf("New connection: socket fd %d, IP %s, port %d\n",
                       new_socket, inet_ntoa(client_addr.sin_addr), ntohs(client_addr.sin_port));
                for (i = 0; i < MAX_CLIENTS; i++) {
                    if (client_sockets[i] == 0) {
                        client_sockets[i] = new_socket;
                        break;
                    }
                }
            }
        }

        // 6. 기존 클라이언트 데이터 처리
        for (i = 0; i < MAX_CLIENTS; i++) {
            client_fd = client_sockets[i];
            if (FD_ISSET(client_fd, &readfds)) {
                int bytes_received = recv(client_fd, buffer, BUFFER_SIZE, 0);
                if (bytes_received <= 0) {
                    printf("Client disconnected: socket fd %d\n", client_fd);
                    close(client_fd);
                    client_sockets[i] = 0;
                } else {
                    buffer[bytes_received] = '\0';
                    printf("Message from client %d: %s\n", client_fd, buffer);
                    send(client_fd, "Message received", 16, 0);
                }
            }
        }
    }

    close(server_fd);
    return 0;
}

실습 요점

  • 다수의 클라이언트 연결 요청을 효율적으로 처리합니다.
  • 클라이언트 메시지를 읽고 응답하는 간단한 서버를 구현합니다.

요약


응용 사례를 통해 select 함수의 유용성을 확인할 수 있으며, 실습 예제를 통해 다중 소켓 처리 방법을 직접 경험할 수 있습니다. 이를 기반으로 더 복잡한 네트워크 애플리케이션을 설계할 수 있습니다.

요약


본 기사에서는 C언어에서 select 함수를 활용한 다중 소켓 처리의 개념과 구현 방법을 다뤘습니다. select 함수의 정의, 주요 파라미터, 동작 과정, 기본 코드 예제, 성능 최적화 기법, 일반적인 오류와 디버깅 방법, 그리고 응용 사례와 실습 예제를 통해 실질적인 네트워크 프로그래밍 기술을 습득할 수 있습니다.

select는 효율적인 다중 소켓 관리를 가능하게 하며, 이를 기반으로 안정적이고 확장 가능한 네트워크 애플리케이션을 설계할 수 있습니다.

C 언어
C언어 select 함수 네트워크 프로그래밍 다중 소켓
목차