linux 使用epoll实现网络通信

最新推荐文章于 2023-12-08 14:15:16 发布
最新推荐文章于 2023-12-08 14:15:16 发布
阅读量557 收藏 4
点赞数
分类专栏： C/C++ linux 计算机网络 文章标签： linux epoll
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhyh1435589631/article/details/50929596
版权
C/C++ 同时被 3 个专栏收录
198 篇文章 0 订阅
订阅专栏
linux
47 篇文章 0 订阅
订阅专栏
计算机网络
8 篇文章 0 订阅
订阅专栏

最近在准备一些面试的相关内容， 正好我们的项目中有个关于多个socket处理内容， 虽然项目中我们偷懒直接使用了匿名管道通信解决了这个问题， 当然好像在我们这个项目中好像也没有方法可以使用select， 或者iocp 模型， 毕竟有一部分socket是人家底层封装好了的。
我们想到了，之前在学习linux的过程中还是使用epoll 写过一个玩具程序的， 虽然是一年前写的， 不过好久没碰过linux了， 还是有些生疏的。我们将自己原先写的代码重新读了一遍， 并加上些注释放到这里， 做个备份。

说下使用epoll进行网络通信：
主要使用3个api ， epoll_create 注册epoll， epoll_ctl设置监听fd的监听事件， epoll_wait等待事件到来

epoll 有两种工作模式：
LT ：当epoll_wait检测到描述符事件发生并将此事件通知应用程序，应用程序可以不立即处理该事件。下次调用epoll_wait时，会再次响应应用程序并通知此事件。

ET： 当epoll_wait检测到描述符事件发生并将此事件通知应用程序，应用程序必须立即处理该事件。如果不处理，下次调用epoll_wait时，不会再次响应应用程序并通知此事件。

ET模式在很大程度上减少了epoll事件被重复触发的次数，因此效率要比LT模式高。epoll工作在ET模式的时候，必须使用非阻塞套接口，以避免由于一个文件句柄的阻塞读/阻塞写操作把处理多个文件描述符的任务饿死。

下面是我们1年之前写的代码
关于代码中使用了goto做一个说明， 使用goto主要是为了方便清理资源， 避免每次都要写重复的资源释放代码， 因为当时这个是个C风格的程序， 不像C++可以使用智能指针进行管理。

server.c

/*
 * server.c
 *
 *  Created on: 2015年4月13日
 *      Author: ThinkPad User
 *      target: 利用epoll实现qq通信
 */

#include "general.h"
#define MAX_EVENTS 10

/*
*   function 设置非阻塞IO
*   input ： fd 表示 输入文件描述符
*/
bool setnonblocking(int fd)
{
    int status = fcntl(fd, F_GETFD);
    if (-1 == status)
    {
        MYTRACE_errno;
        return false;
    }

    int res = fcntl(fd, F_SETFD, status | O_NONBLOCK);
    if (-1 == res)
    {
        MYTRACE_errno;
        return false;
    }

    return true;
}

int main(int arg, char * args[])
{
    BOOL bRet = FALSE;
    int epollfd;
    int sockfd;
    int sockcli = -1;
    do
    {
        /****************************************************************************/
        /*         正常创建socket的流程           socket, bind, listen, setnonblocking  */
        /****************************************************************************/
        //int port = 8000;
        if (arg < 2)
        {
            MYTRACE("Missing port information\n");
            return bRet;
        }
        int port = atoi(args[1]);

        sockfd = socket(AF_INET, SOCK_STREAM, 0);
        if (-1 == sockfd)
        {
            MYTRACE_errno;
            break;
        }

        struct sockaddr_in sock_serv;
        sock_serv.sin_family = AF_INET;
        sock_serv.sin_port = htons(port);
        sock_serv.sin_addr.s_addr = htonl(INADDR_ANY);

        int res = bind(sockfd, (struct sockaddr *)&sock_serv, sizeof(struct sockaddr));
        if (-1 == res)
        {
            MYTRACE_errno;
            break;
        }

        res = listen(sockfd, 5);
        if (-1 == res)
        {
            MYTRACE_errno;
            break;
        }

        res = setnonblocking(sockfd);
        if (false == res)
        {
            break;
        }

        /****************************************************************************/
        /*         epoll 处理                                                       */
        /****************************************************************************/
        epollfd = epoll_create(MAX_EVENTS);
        if (-1 == epollfd)
        {
            MYTRACE_errno;
            break;
        }

        struct epoll_event events[MAX_EVENTS];
        struct epoll_event ev;

        // 设置监听 内容为数据输入
        ev.events = EPOLLIN | EPOLLERR | EPOLLHUP;
        ev.data.fd = sockfd;
        res = epoll_ctl(epollfd, EPOLL_CTL_ADD, sockfd, &ev);
        if (-1 == res)
        {
            MYTRACE_errno;
            break;
        }

        while(TRUE)
        {
            // 等待数据到来， res 为有数据的socket的个数
            res = epoll_wait(epollfd, events, MAX_EVENTS, -1);
            if (-1 == res)
            {
                MYTRACE_errno;
                goto END;
            }

            int i = 0;
            for (; i < res; ++i)
            {
                // 如果是 sockfd 得到数据， 表明有客户端连接过来了
                if (sockfd == events[i].data.fd)
                {
                    struct sockaddr_in addr_cli;
                    socklen_t len = sizeof(struct sockaddr);
                    sockcli = accept(sockfd, (struct sockaddr *)&addr_cli, &len);
                    if (-1 == sockcli)
                    {
                        MYTRACE_errno;
                        goto END;
                    }

                    printf("%s connected\n", inet_ntoa(addr_cli.sin_addr));

                    res = setnonblocking(sockcli);
                    if (false == res)
                    {
                        close(sockcli);
                        goto END;
                    }

                    // 将客户端 的sockcli 加入epoll池中， 监听他的数据收发消息
                    ev.events = EPOLLIN | EPOLLOUT;
                    ev.data.fd = sockcli;
                    res = epoll_ctl(epollfd, EPOLL_CTL_ADD, sockcli, &ev);
                    if (-1 == res)
                    {
                        MYTRACE_errno;
                        goto END;
                    }
                }

                else
                {
                    /*
                    if (events[i].events & EPOLLHUP)
                    {
                        MYTRACE("error");
                        events[i].data.fd = -1;
                    }

                    if (events[i].events & EPOLLERR)
                    {
                        MYTRACE("error");
                        events[i].data.fd = -1;
                    }
                    */

                    // 数据接收
                    if (events[i].events & EPOLLIN)
                    {
                        char buf[MAX_BYTE] = {0};
                        res = recv(sockcli, buf, MAX_BYTE, 0);
                        if (res == -1)
                        {
                            MYTRACE_noerrno;
                            goto END;
                        }

                        printf("recv: %s\n", buf);
                        memset(buf, 0, MAX_BYTE);
                    }

                    // 数据发送
                    if (events[i].events & EPOLLOUT)
                    {
                        char buf[MAX_BYTE] = {0};
                        res = read(STDIN_FILENO, buf, MAX_BYTE);
                        if (-1 == res)
                        {
                            MYTRACE_errno;
                            goto END;
                        }

                        res = send(sockcli, buf, res, 0);
                        if (res == -1)
                        {
                            MYTRACE_noerrno;
                            goto END;
                        }

                        printf("send: %d byte\n", res);
                        memset(buf, 0, MAX_BYTE);
                    }
                }

            }
        }

        bRet = TRUE;
    }while (FALSE);

END:
    if (epollfd)
        close(epollfd);
    if (sockfd)
        close(sockfd);
    return bRet;
}

client.c

/*
 * tcp_client.c
 *
 *  Created on: 2015年4月8日
 *      Author: ThinkPad User
 */


#include "general.h"

pthread_mutex_t g_mutex;

typedef struct _packet
{
    int sockfd;
    pthread_t * pthr;
}packet;

// 发送数据
void * sock_send(void * args)
{
    int sock = *(int *)args;
    do
    {
        char szbuf[MAX_BYTE] = {0};
        while(TRUE)
        {
            int res = read(STDIN_FILENO, szbuf, MAX_BYTE);
            if (-1 == res)
            {
                MYTRACE_errno;
                break;
            }

            res = send(sock, szbuf, strlen(szbuf), 0);
            if (-1 == res)
            {
                MYTRACE_errno;
                break;
            }

            printf("send : %d byte\n", res);
            memset(szbuf, 0, MAX_BYTE);
        }

    }while (FALSE);

    return NULL;
}

// 接收数据
void * sock_recv(void * args)
{
    packet ps = *(packet *)args;
    int sock = ps.sockfd;
    pthread_t thr = *ps.pthr;
    do
    {
        char szbuf[MAX_BYTE] = {0};
        while(TRUE)
        {
            int res = recv(sock, szbuf, MAX_BYTE, 0);
            if (-1 == res)
            {
                MYTRACE_noerrno;
                break;
            }

            res = write(STDOUT_FILENO, szbuf, strlen(szbuf));
            if (-1 == res)
            {
                MYTRACE_errno;
                break;
            }

            memset(szbuf, 0, MAX_BYTE);
        }

    }while (FALSE);

    pthread_cancel(thr);

    return NULL;
}



int main(int arg, char * args[])
{
    BOOL bRet = FALSE;
    if (arg < 3)
    {
        MYTRACE("missing port and IP information\n");
        return bRet;
    }

    do
    {
        int sock_serv = socket(AF_INET, SOCK_STREAM, 0);
        if (-1 == sock_serv)
        {
            MYTRACE_errno;
            break;
        }

        int port = atoi(args[2]);
        char * IP = args[1];

        struct sockaddr_in sock_addr;
        sock_addr.sin_family = AF_INET;
        sock_addr.sin_port = htons(port);
        sock_addr.sin_addr.s_addr = inet_addr(IP);

        int res = connect(sock_serv, (struct sockaddr *)&sock_addr, sizeof(struct sockaddr));
        if (-1 == res)
        {
            MYTRACE_errno;
            break;
        }

        // 使用 pthread_create 创建子线程
        pthread_t thr_send, thr_recv;
        int errnum = pthread_create(&thr_send, NULL, sock_send, (void *)&sock_serv);
        if (0 != errnum)
        {
            MYTRACE_noerrno;
            break;
        }

        packet ps;
        ps.sockfd = sock_serv;
        ps.pthr = &thr_send;
        errnum = pthread_create(&thr_recv, NULL, sock_recv, (void *)&ps);
        if (0 != errnum)
        {
            MYTRACE_noerrno;
            break;
        }

        errnum = pthread_join(thr_send, NULL);
        if (0 != errnum)
        {
            MYTRACE_noerrno;
            break;
        }

        errnum = pthread_join(thr_recv, NULL);
        if (0 != errnum)
        {
            MYTRACE_noerrno;
            break;
        }

        bRet = TRUE;
    }while (FALSE);

    return bRet;
}

general.h

/*
 * general.h
 *
 *  Created on: 2015年4月1日
 *      Author: ThinkPad User
 *      鉴于每次写linux程序的时候需要调用各种头文件，查找起来非常的不爽，这里将
 *      常用的几个头文件罗列在这里,以后直接调用这个头文件就可以了
 */

#ifndef GENERAL_H_
#define GENERAL_H_

#ifdef __cplusplus
extern "C"
{
#endif
// common headers
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/wait.h>
#include <time.h>
#include <signal.h>
#include <sys/klog.h>

// 线程
#include <pthread.h>

// internet
#include <sys/socket.h>
#include <arpa/inet.h>

// epoll
#include <sys/epoll.h>



// support bool operations
#define TRUE 1
#define FALSE 0
typedef int BOOL;

#define true 1
#define false 0
typedef int bool;

// define buffer size
#define MAX_BYTE 0xFF
#define MAX_BUFFER 64*1024

// trace for debug
#define MYTRACE(condition)  printf("%s %s: [%s](%d)<%s> %s error\n", __DATE__, __TIME__, __FILE__, __LINE__, __FUNCTION__, condition)
#define MYTRACE_errno   printf("%s %s: [%s](%d)<%s> error: %s\n", __DATE__, __TIME__, __FILE__, __LINE__, __FUNCTION__, strerror(errno))
#define MYTRACE_noerrno     printf("%s %s: [%s](%d)<%s> error\n", __DATE__, __TIME__, __FILE__, __LINE__, __FUNCTION__)

// create my signal1 in replace of signal
int signal1(int signum, void(*func)(int))
{
    struct sigaction act, oact;
    act.sa_handler = func;
    sigemptyset(&act.sa_mask);
    act.sa_flags = 0;
    return sigaction(signum, &act, &oact);
}

#ifdef __cplusplus
}
#endif
#endif /* GENERAL_H_ */

makefile

.SUFFIXES:.c .o

CC = gcc
SRC = client.c
OBJ = $(SRC:.c=.o)
EXEC = client

SRC1 = server.c
OBJ1 = $(SRC1:.c=.o)
EXEC1 = server

start:$(OBJ) $(OBJ1)
    $(CC) -o $(EXEC) $(OBJ) -pthread
    $(CC) -o $(EXEC1) $(OBJ1)
    @echo '--------------------done-----------------------'

.c.o:
    $(CC) -Wall -g -o $@ -c $<

clean:
    rm -f $(OBJ)
    rm -f $(OBJ1)
    rm -f core*

参考资源：
IO多路复用之epoll总结

枯萎的海风
关注
专栏目录
Linux下epoll实现简易聊天
12-03
在Linux操作系统中，epoll是I/O多路复用技术的一种高效实现，常用于高性能网络服务，例如聊天应用。这个“Linux下epoll实现简易聊天”项目提供了使用epoll实现简单QQ聊天应用的源代码，旨在帮助开发者了解如何在实际...
LinuxC 进程间的通信：基于文件的 pipe()匿名管道 mkfifo()命名管道 epoll()多文件
qq_33373173的博客
08-17 296
pipe() 匿名管道 创建匿名管道 局限性:两端进程须具有共同祖先 及文件描述符指向同一文件 #include <unistd.h> int pipe(int pipefd[2]); 数组第一个元素为读取数据的文件描述符 第二个元素为写入数据的文件描述符 mkfifo() 命名管道 命名管道创建以后可以被任何进程像文件一样使用，须读写进程必须同时出现 #include <sys/types.h> #include <sys/stat.h> int mkfi
linux C++监听管道文件方式
最新发布
qq_42145185的博客
12-08 376
非阻塞打开文件，用read循环定时读取，性能不好。
C/C++开发，基于epoll的tcp-socket通信服务模块
技术需要分享
05-07 1115
最近一直研究对自己的开源物联网边缘服务瘦身，已适应更短缺资源的设备上运行，因此需要裁减第三方库的依赖，由于原先tcp-socket通信是调用第三方库的，因此准备动手为开源项目写一个简要适合项目需要的服务模块。 由于服务端需要针对每个客户端进行定制下行通讯需求，因此采用epoll以便于明确知道句柄进行特定通信。
C++实现linux异步高并发网络收发通讯
QtCompany的博客
04-24 669
上述代码实现了一个简单的回显服务器，它可以同时处理多个客户端的请求，并通过线程池和异步编程模型提高了程序的并发性和响应速度。您可以根据自己的需求进行修改和扩展。异步编程模型：异步编程模型将任务的执行与I/O操作分离开来，使得主线程可以继续处理其他任务，从而提高程序的并发性和响应速度。Socket编程：Socket编程是C++实现网络通信的基础，它提供了一套API，用于在网络上进行数据传输。线程池：线程池是一种管理和复用线程的机制，可以避免频繁地创建和销毁线程，从而提高程序的性能和可维护性。
linux网络编程epoll详解
weixin_40355471的博客
12-04 4374
epoll_create，epoll_ctl，epoll_wait，epoll的触发模式，边沿触发：edge-triggered (EPOLLET)， 水平触发：level-triggered (EPOLLLT)，epoll原理解析，中断和阻塞，socket接收网络数据，epoll的设计思路，epoll的工作流程，就绪列表Rdlist，eventpoll，索引结构RBR。
linux epoll socket UDP通信的实现! 看清楚不是tcp哟.zip
01-19
本篇文章将深入探讨如何在Linux环境下使用`epoll`与`socket`实现UDP通信。 首先，我们需要了解UDP（User Datagram Protocol）是一种无连接的、不可靠的传输层协议，它的主要特点是速度快、开销小，但不保证数据的...
epoll实现cs通信.zip
08-18
这个名为"epoll实现cs通信.zip"的压缩包包含了一组用于演示如何使用epoll实现客户端（Client）与服务器端（Server）通信的源代码文件。下面将详细介绍epoll的工作原理以及压缩包中的文件内容。 1. **epoll的工作...
Linux网络通信epoll模型
07-24
总的来说，epoll模型是Linux系统中实现高并发网络服务的重要工具，它通过优化的事件通知机制，显著提升了程序处理能力，使得开发者能够构建出更加稳定、高效的网络应用。通过阅读和理解`epollServer.cpp`和`client....
linux c epoll服务器windows 客户端通信
03-21
本文将深入探讨如何使用Linux C的epoll服务器与Windows Socket客户端进行通信。Epoll是Linux内核提供的一种高效I/O事件通知机制，而Windows Socket API是微软提供的用于网络编程的标准接口。 首先，我们来理解Linux...
epoll 获取串口数据（封装为函数）
12-13
把epoll接收数据封装为接口形式供线程调用
linux下通过epoll机制进行串口监听并转发tcp
09-02
Linux下通过epoll机制进行串口监听，当收到数据时，通过tcp进行数据转发给服务器
linux条件下利用epoll 接收串口数据
12-13
linux系统下，利用epoll接收串口助手发来的数据并打印。
Linux 中的 epoll 原理及使用
热门推荐
私房菜
02-12 1万+
epoll 简介 epoll是Linux内核中的一种可扩展IO事件处理机制，最早在 Linux 2.5.44内核中引入，可被用于代替POSIX select 和 poll 系统调用，并且在具有大量应用程序请求时能够获得较好的性能（ 此时被监视的文件描述符数目非常大，与旧的 select 和 poll 系统调用完成操作所需 O(n) 不同， epoll能在O(1)时间内完成操作，所以性能相当高）...
C/C++开发，利用epoll创建自己的后台服务，实现对各个客户端网络通信（含示例代码）
技术需要分享
09-21 1116
利用epoll创建自己的后台服务，实现对各个客户端网络通信（含示例代码），设计一个epoll线程接口类包含线程能力、epoll API能力及消息缓存队列能力
epoll机制读取linux串口数据
coding__madman的博客
06-14 9141
epoll和select相比，最大不同在于: 1epoll返回时已经明确的知道哪个sokcet fd发生了事件，不用再一个个比对。这样就提高了效率。 2select的FD_SETSIZE是有限止的，而epoll是没有限止的只与系统资源有关。
Linux网络通信-----epoll
weixin_43743711的博客
06-26 234
epoll简述： epoll是当前在Linux下开发大规模并发网络程序的热门选择，是Linux内核中的一种可扩展IO事件处理机制，可被用于代替POSIX select 和 poll 系统调用，并且在具有大量应用程序请求时能够获得较好的性能（此时被监视的文件描述符数目非常大，与旧的 select 和 poll 系统调用完成操作所需 O(n) 不同， epoll能在O(1)时间内完成操作，所以性能相当高），epoll在Linux2.6内核中正式引入，和select相似，都是IO多路复用（IO multiplex
Linux I/O多路复用——epoll模型实现服务端Socket通信
HerofH_的博客
03-15 3292
目录 epoll模型 epoll函数 epoll_create epoll_ctl epoll_wait 程序流程 水平触发（LT） 边沿触发（ET） select、poll、epoll对比 为什么ET模式下，需要将套接字设置为非阻塞式？ epoll模型 epoll是Linux下多路复用IO接口select/poll的增强版本。 　　它能显著减少程序在大量...
linux下epoll如何实现高效处理百万句柄的
yiyeqinghuasoon
01-06 1884
开发高性能网络程序时，windows开发者们言必称iocp，linux开发者们则言必称epoll。大家都明白epoll是一种IO多路复用技术，可以非常高效的处理数以百万计的socket句柄，比起以前的select和poll效率高大发了。我们用起epoll来都感觉挺爽，确实快，那么，它到底为什么可以高速处理这么多并发连接呢？ 先简单回顾下如何使用C库封装的3个epoll系统调用吧。 in...
Linux下基于epoll的socket通信库实现
通过这份资源，开发者可以学习到如何在Linux系统下编写高效的网络通信库，掌握epoll机制的使用，并能够将其应用于实际的网络编程项目中。这对于希望提高应用程序网络性能和处理大规模并发连接的开发者来说，是一个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值