Linux网络编程 - 基于 I/O 复用的聊天服务器端(epoll：LT 和 ET 模式实现)

yunfan188

已于 2022-01-22 20:16:27 修改

阅读量1.6k

点赞数 1

分类专栏： Linux编程 # 并发编程 # 网络编程文章标签： Linux网络编程 socket编程 I/O复用 epoll 多线程

于 2022-01-22 18:21:37 首次发布

本文链接：https://blog.youkuaiyun.com/u010429831/article/details/122632528

版权

网络编程同时被 3 个专栏收录

24 篇文章

订阅专栏

并发编程

16 篇文章

订阅专栏

Linux编程

15 篇文章

订阅专栏

本文介绍如何使用epoll实现聊天服务器端，包括条件触发和边缘触发两种方式，同时提供基于多线程的聊天客户端实现。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

一问题描述

实现聊天服务器端，使其可以在连接到服务器端的所有客户端之间交换消息。按照条件触发方式和边缘触发方式分别实现 epoll 服务器端（聊天服务器端的实现中，这两种方式不会产生太大差异）。当然，为了正常运行服务器端，需要聊天客户端，我们可以使用多线程编程模型实现聊天客户端。

二基于 epoll 实现聊天服务器端

2.1 基于 epoll 条件触发方式实现聊天服务器端

chat_EPLTserv.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <fcntl.h>
#include <arpa/inet.h>
#include <sys/socket.h>
#include <sys/epoll.h>
#include <errno.h>

#define BUF_SIZE 1024
#define MAX_CLNT 256
#define EPOLL_SIZE 50

typedef struct sockaddr SA;

void error_handling(char *buf);
void send_msg(char * msg, int len);

int clnt_cnt=0;             //记录客户端的连接数
int clnt_socks[MAX_CLNT];   //存放与所有客户端数据交互的套接字文件描述符数组

int main(int argc, char *argv[])
{
    int serv_sock, clnt_sock;
    struct sockaddr_in serv_adr, clnt_adr;
    socklen_t clnt_adr_sz;
    int str_len, i, fd;
    char buf[BUF_SIZE];

    struct epoll_event *ep_events;
    struct epoll_event event;
    int epfd, event_cnt;

    if(argc!=2) {
        printf("Usage: %s <port>\n", argv[0]);
        exit(1);
    }

    serv_sock=socket(PF_INET, SOCK_STREAM, 0);
    memset(&serv_adr, 0, sizeof(serv_adr));
    serv_adr.sin_family=AF_INET;
    serv_adr.sin_addr.s_addr=htonl(INADDR_ANY);
    serv_adr.sin_port=htons(atoi(argv[1]));
    
    if(bind(serv_sock, (struct sockaddr*) &serv_adr, sizeof(serv_adr))==-1)
        error_handling("bind() error");
    if(listen(serv_sock, 5)==-1)
        error_handling("listen() error");

    epfd=epoll_create(EPOLL_SIZE);
    ep_events=malloc(sizeof(struct epoll_event)*EPOLL_SIZE);

    event.events=EPOLLIN;
    event.data.fd=serv_sock;    
    epoll_ctl(epfd, EPOLL_CTL_ADD, serv_sock, &event);

    while(1)
    {
        event_cnt=epoll_wait(epfd, ep_events, EPOLL_SIZE, -1);
        if(event_cnt == -1)
        {
            error_handling("epoll_wait() error!");
            break;
        }

        for(i=0; i<event_cnt; i++)
        {
            fd = ep_events[i].data.fd;
            if(fd == serv_sock)
            {
                clnt_adr_sz=sizeof(clnt_adr);
                clnt_sock=accept(serv_sock, (SA*)&clnt_adr, &clnt_adr_sz);
                if(clnt_sock == -1)
                {
                    printf("accept() error! %d:%s\n", errno, strerror(errno));
                    break;
                }
                //注册与客户端进行数据交互的套接字文件描述符clnt_sock，并注册该描述符上的读事件
                event.events=EPOLLIN;
                event.data.fd=clnt_sock;
                epoll_ctl(epfd, EPOLL_CTL_ADD, clnt_sock, &event);
                clnt_socks[clnt_cnt++]=clnt_sock;
                printf("New client connected from address[%s:%d], conn_fd=%d\n", 
                        inet_ntoa(clnt_adr.sin_addr), ntohs(clnt_adr.sin_port), clnt_sock);         
            }
            else  //接收客户端发送来的消息
            {
                str_len=read(fd, buf, BUF_SIZE);
                if(str_len==0)    //接收到EOF时，关闭套接字连接
                {
                    epoll_ctl(epfd, EPOLL_CTL_DEL, fd, NULL);
                    close(fd);
                    printf("closed client, clnt_fd=%d\n", fd);

                    for(i=0; i<clnt_cnt; i++)  //从clnt_socks数组中删除掉关闭连接的文件描述符
                    {
                        if(clnt_sock==clnt_socks[i])
                        {
                            while(i++<clnt_cnt-1)
                                clnt_socks[i]=clnt_socks[i+1];
                            break;
                        }
                    }
                    clnt_cnt--;                //客户端连接数减1
                }
                else
                {
                    send_msg(buf, str_len);
                }
            }
        }
    }
    close(serv_sock);
    close(epfd);
    return 0;
}

//向所有连接客户端转发收到的消息
void send_msg(char * msg, int len)
{
    int i;
    for(i=0; i<clnt_cnt; i++)
        write(clnt_socks[i], msg, len);
}

void error_handling(char *buf)
{
    fputs(buf, stderr);
    fputc('\n', stderr);
    exit(1);
}

2.1 基于 epoll 边缘触发方式实现聊天服务器端

chat_EPETserv.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <fcntl.h>
#include <arpa/inet.h>
#include <sys/socket.h>
#include <sys/epoll.h>
#include <errno.h>

#define BUF_SIZE 1024
#define MAX_CLNT 256
#define EPOLL_SIZE 50

typedef struct sockaddr SA;

int set_nonblocking(int fd);
void error_handling(char *buf);
void send_msg(char * msg, int len);

int clnt_cnt=0;             //记录客户端的连接数
int clnt_socks[MAX_CLNT];   //存放与所有客户端数据交互的套接字文件描述符数组

int main(int argc, char *argv[])
{
    int serv_sock, clnt_sock;
    struct sockaddr_in serv_adr, clnt_adr;
    socklen_t clnt_adr_sz;
    int str_len, i, fd;
    char buf[BUF_SIZE];

    struct epoll_event *ep_events;
    struct epoll_event event;
    int epfd, event_cnt;

    if(argc!=2) {
        printf("Usage: %s <port>\n", argv[0]);
        exit(1);
    }

    serv_sock=socket(PF_INET, SOCK_STREAM, 0);
    memset(&serv_adr, 0, sizeof(serv_adr));
    serv_adr.sin_family=AF_INET;
    serv_adr.sin_addr.s_addr=htonl(INADDR_ANY);
    serv_adr.sin_port=htons(atoi(argv[1]));
    
    if(bind(serv_sock, (struct sockaddr*) &serv_adr, sizeof(serv_adr))==-1)
        error_handling("bind() error");
    if(listen(serv_sock, 5)==-1)
        error_handling("listen() error");

    epfd=epoll_create(EPOLL_SIZE);
    ep_events=malloc(sizeof(struct epoll_event)*EPOLL_SIZE);

    set_nonblocking(serv_sock);     //设置服务器端套接字为非阻塞模式
    event.events=EPOLLIN;
    event.data.fd=serv_sock;
    epoll_ctl(epfd, EPOLL_CTL_ADD, serv_sock, &event);

    while(1)
    {
        event_cnt=epoll_wait(epfd, ep_events, EPOLL_SIZE, -1);
        if(event_cnt == -1)
        {
            error_handling("epoll_wait() error!");
            break;
        }

        for(i=0; i<event_cnt; i++)
        {
            fd = ep_events[i].data.fd;
            if(fd == serv_sock)
            {
                clnt_adr_sz=sizeof(clnt_adr);
                clnt_sock=accept(serv_sock, (SA*)&clnt_adr, &clnt_adr_sz);
                if(clnt_sock == -1)
                {
                    printf("accept() error! %d:%s\n", errno, strerror(errno));
                    break;
                }
                //注册与客户端进行数据交互的套接字文件描述符clnt_sock，并注册该描述符上的读事件
                set_nonblocking(clnt_sock);     //设置与客户端进行数据交互的套接字为非阻塞模式
                event.events=EPOLLIN|EPOLLET;   //添加ET模式标识符EPOLLET
                event.data.fd=clnt_sock;
                epoll_ctl(epfd, EPOLL_CTL_ADD, clnt_sock, &event);
                clnt_socks[clnt_cnt++]=clnt_sock;
                printf("New client connected from address[%s:%d], conn_fd=%d\n", 
                        inet_ntoa(clnt_adr.sin_addr), ntohs(clnt_adr.sin_port), clnt_sock);         
            }
            else  //接收客户端发送来的消息
            {
                while(1)
                {
                    str_len=read(fd, buf, BUF_SIZE);
                    if(str_len == 0)    //接收到EOF时，关闭套接字连接
                    {
                        epoll_ctl(epfd, EPOLL_CTL_DEL, fd, NULL);
                        close(fd);
                        printf("closed client, clnt_fd=%d\n", fd);

                        for(i=0; i<clnt_cnt; i++)  //从clnt_socks数组中删除掉关闭连接的文件描述符
                        {
                            if(clnt_sock==clnt_socks[i])
                            {
                                while(i++<clnt_cnt-1)
                                    clnt_socks[i]=clnt_socks[i+1];
                                break;
                            }
                        }
                        clnt_cnt--;           //客户端连接数减1
                        break;
                    }
                    else if(str_len < 0)
                    {
                        if(errno == EAGAIN)   //如果套接字接收缓冲为空
                            break;
                    }
                    else
                    {
                        send_msg(buf, str_len);
                    }
                }
            }
        }
    }
    close(serv_sock);
    close(epfd);
    return 0;
}

//将文件描述符设置为非阻塞模式
int set_nonblocking(int fd)
{
    int flags;
    if((flags = fcntl(fd, F_GETFL, NULL)) < 0){
        printf("set non-block error:%d %s\n", errno, strerror(errno));
        return -1;
    }
    if(fcntl(fd, F_SETFL, flags | O_NONBLOCK) < 0){
        printf("set non-block error:%d %s\n", errno, strerror(errno));
        return -2;
    }
    return 0;
}

//向所有连接客户端转发收到的消息
void send_msg(char * msg, int len)
{
    int i;
    for(i=0; i<clnt_cnt; i++)
        write(clnt_socks[i], msg, len);
}

void error_handling(char *buf)
{
    fputs(buf, stderr);
    fputc('\n', stderr);
    exit(1);
}

三基于多线程实现聊天客户端

chat_clnt.c

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

#define BUF_SIZE  1024
#define NAME_SIZE 30

typedef struct sockaddr SA;

void error_handling(char *message);
void* send_msg(void *arg);
void* recv_msg(void *arg);

char name[NAME_SIZE]="[DEFAULT]";
char msg[BUF_SIZE] = {0};

int main(int argc, char *argv[])
{
    int sockfd;
    struct sockaddr_in serv_adr;
    pthread_t snd_thread, rcv_thread;
    void *retval;
    
    if(argc != 4){
        printf("Usage: %s <IP> <Port> <Name>\n", argv[0]);
        exit(1);
    }
    sprintf(name, "[%s]", argv[3]);
    
    sockfd = socket(PF_INET, SOCK_STREAM, 0);
    serv_adr.sin_family = AF_INET;
    serv_adr.sin_addr.s_addr = inet_addr(argv[1]);
    serv_adr.sin_port = htons(atoi(argv[2]));
    
    if(connect(sockfd, (SA*)&serv_adr, sizeof(serv_adr)) == -1)
        error_handling("connect() error!");
    
    pthread_create(&snd_thread, NULL, send_msg, &sockfd);  //创建发送消息线程
    pthread_create(&snd_thread, NULL, recv_msg, &sockfd);  //创建接收消息函数
    pthread_join(snd_thread, &retval);                     //等待发送消息线程结束
    pthread_join(rcv_thread, &retval);                     //等待接收消息线程结束
    close(sockfd);
    return 0;
}

//处理发送消息的线程函数
void* send_msg(void *arg)
{
    int sockfd = *(int*)arg;
    char name_msg[NAME_SIZE+BUF_SIZE] = {0};
    while(1)
    {
        fgets(msg, BUF_SIZE, stdin);  //控制台(终端)输入一行字符串
        if(!strcmp(msg, "q\n") || !strcmp(msg, "Q\n"))  //退出条件
        {
            close(sockfd);
            exit(0);
        }
        sprintf(name_msg, "%s %s", name, msg);
        write(sockfd, name_msg, strlen(name_msg));  //向服务器端发送字符串消息
    }
    return NULL;
}

//处理接收消息的线程函数
void* recv_msg(void *arg)
{
    int sockfd = *(int*)arg;
    char name_msg[NAME_SIZE+BUF_SIZE] = {0};
    int str_len;
    
    while(1)
    {
        str_len = read(sockfd, name_msg, NAME_SIZE+BUF_SIZE-1);
        if(str_len <= 0)
            pthread_exit((void*)2);   //线程主动退出
        name_msg[str_len] = 0;
        fputs(name_msg, stdout);      //控制台(终端)输出收到的字符串消息
    }
    return NULL;
}

void error_handling(char *message)
{
    fputs(message, stderr);
    fputc('\n', stderr);
    exit(1);
}

四运行结果

4.1 聊天服务器端运行结果

服务器端：chat_EPLTserv.c

$ gcc chat_EPLTserv.c -o EPLTserv
$ ./EPLTserv 9190
New client connected from address[127.0.0.1:45448], conn_fd=5
New client connected from address[127.0.0.1:45450], conn_fd=6
closed client, clnt_fd=5
closed client, clnt_fd=6

服务器端：chat_EPETserv.c

$ gcc chat_EPETserv.c -o EPETserv
$ ./EPETserv 9190
New client connected from address[127.0.0.1:45452], conn_fd=5
New client connected from address[127.0.0.1:45454], conn_fd=6
closed client, clnt_fd=5
closed client, clnt_fd=6

4.2 聊天客户端运行结果

客户端1：chat_clnt.c

$ gcc chat_clnt.c -D_REENTRANT -o client -lpthread
$ ./client 127.0.0.1 9190 Jack
Hi, everyone~
[Jack] Hi, everyone~
[Lee] Hi, Jack~
Nice to meet you, Lee
[Jack] Nice to meet you, Lee
[Lee] Nice to meet you, too
Q

客户端2：chat_clnt.c

$ ./client 127.0.0.1 9190 Lee
[Jack] Hi, everyone~
Hi, Jack~
[Lee] Hi, Jack~
[Jack] Nice to meet you, Lee
Nice to meet you, too
[Lee] Nice to meet you, too
Q