Linux的tcp服务器连接的几种方式（线程、select、poll、epoll）

最新推荐文章于 2024-04-26 16:31:32 发布
最新推荐文章于 2024-04-26 16:31:32 发布
阅读量721 收藏 3
点赞数 1
文章标签： linux c++ 服务器 tcp
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_57177980/article/details/130169585
版权

1. 一次性连接

客服端与服务器连接一次，服务器只收发一次数据

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

#include <fcntl.h>


#define BUFFER_LENGTH        1024

int main() { 
    
    int sockfd = socket(AF_INET, SOCK_STREAM, 0); //io

    struct sockaddr_in servaddr;
    memset(&servaddr, 0, sizeof(struct sockaddr_in)); // 192.168.1.123
    servaddr.sin_family = AF_INET;
    servaddr.sin_addr.s_addr = htonl(INADDR_ANY); // 0.0.0.0
    servaddr.sin_port = htons(9999);

    if(-1 == bind(sockfd, (struct sockaddr*)&servaddr, sizeof(struct sockaddr))) { 
        printf(" bind failed: %s", strerror(errno));
        return -1;
    }
    
    listen(sockfd, 10);        

    //sleep(10);

    struct sockaddr_in clientaddr;
    socklen_t len = sizeof(clientaddr);
    int clientfd = accept(sockfd, (struct sockaddr*)&clientaddr, &len);    // 有客户端连接才往下走，否则阻塞在这里

    printf("clientfd: %d, sockfd: %d\n", clientfd, sockfd);
    
    char buffer[BUFFER_LENGTH] = {0};
    int ret = recv(clientfd, buffer, BUFFER_LENGTH, 0);
    
    printf("buffer: %s\n", buffer);

    send(clientfd, buffer, ret, 0);

    
    getchar();    //block

    return 0;
    

}

2. 一连接一线程

可以实现多个客户端与服务器连接，服务器可以多次收发数据

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

#include <fcntl.h>
#include <pthread.h>


#define BUFFER_LENGTH        1024

//一连接一线程
void *client_thread(void * arg) {    // 业务线程

    int clientfd = *(int*)arg;

    while (1) {
        char buffer[BUFFER_LENGTH] = {0};
        int ret = recv(clientfd, buffer, BUFFER_LENGTH, 0);
        if(ret == 0) {
            close(clientfd);
            break;
        }
        printf("clientfd: %d, buffer: %s\n",clientfd, buffer);

        send(clientfd, buffer, ret, 0);
    }
}

int main() { 
    
    int sockfd = socket(AF_INET, SOCK_STREAM, 0); //io

    struct sockaddr_in servaddr;
    memset(&servaddr, 0, sizeof(struct sockaddr_in)); // 192.168.1.123
    servaddr.sin_family = AF_INET;
    servaddr.sin_addr.s_addr = htonl(INADDR_ANY); // 0.0.0.0
    servaddr.sin_port = htons(9999);

    if(-1 == bind(sockfd, (struct sockaddr*)&servaddr, sizeof(struct sockaddr))) { 
        printf(" bind failed: %s", strerror(errno));
        return -1;
    }
    
    listen(sockfd, 10);        

    //sleep(10);

    struct sockaddr_in clientaddr;
    socklen_t len = sizeof(clientaddr);

    int clientfd = 0;
    
    while (1) {    // master 主线程

        clientfd = accept(sockfd, (struct sockaddr*)&clientaddr, &len);    // 有客户端连接才往下走，否则阻塞在这里
        printf("clientfd: %d, sockfd: %d\n", clientfd, sockfd);

        pthread_t threadid;
        pthread_create(&threadid, NULL, client_thread, &clientfd);
    }
    
    //getchar();    //block

    return 0;
}


3. select 

select(maxfd, rfds, wfds, efds, timeout);
maxfd：fd的最大值，select中依靠这个值轮询，像是for()里的 int i
rfds：可读的集合
wfds：可写的集合
efds：出错的集合
timeout：多少时间轮询一次

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

#include <fcntl.h>
#include <pthread.h>


#define BUFFER_LENGTH        1024
#define POLL_SIZE            1024

int main() { 
    //open
    
    int sockfd = socket(AF_INET, SOCK_STREAM, 0); //io

    struct sockaddr_in servaddr;
    memset(&servaddr, 0, sizeof(struct sockaddr_in)); // 192.168.1.123
    servaddr.sin_family = AF_INET;
    servaddr.sin_addr.s_addr = htonl(INADDR_ANY); // 0.0.0.0
    servaddr.sin_port = htons(9999);

    if(-1 == bind(sockfd, (struct sockaddr*)&servaddr, sizeof(struct sockaddr))) {
        printf(" bind failed: %s", strerror(errno));
        return -1;
    }
    
    listen(sockfd, 10);        

    
    struct sockaddr_in clientaddr;
    socklen_t len = sizeof(clientaddr);
    
    // nready 表示select中有多少个需要处理的io
    //select(maxfd, rfds, wfds, efds, timeout);// maxfd：fd的最大值，select中依靠这个值轮询，rfds：可读的集合，wfds：可写的集合，efds：出错的集合，timeout：多少时间轮询一次

    fd_set rfds, rset; // bit数组, 如果某个位置的bit位为1，则说明对应的fd有响应
    FD_ZERO(&rfds);    // 将rfds的每个bit位 置为零
    FD_SET(sockfd, &rfds);

    int maxfd = sockfd;    // 在select里相当于for()循环里的int i;
    int clientfd = 0;
    while (1) {

        rset = rfds; // 交给内核的io集合
        // nready 表示select中有多少个需要处理的io        
        int nready = select(maxfd + 1, &rset, NULL, NULL, NULL);// maxfd：fd的最大值，select中依靠这个值轮询，rfds：可读的集合，wfds：可写的集合，efds：出错的集合，timeout：多少时间轮询一次

        if (FD_ISSET(sockfd, &rset)) {
            clientfd = accept(sockfd, (struct sockaddr*)&clientaddr, &len); // 有客户端连接才往下走，否则阻塞在这里
            printf("accept: %d, sockfd: %d\n", clientfd, sockfd);

            
            FD_SET(clientfd, &rfds);
            if (clientfd > maxfd)    maxfd = clientfd; // 假设当前连接的fd有4 5 6 7，但是当6断开后（4 5 7），再有客户端连接会顶替6的空缺（4 5 6 7），
                                                      // 但是如果我们打开了一个普通文件顶替了6的空缺， 就有可能把这个普通文件当作io来操作

            if (--nready == 0)    continue;
        }

        int i = 0;
        for (i = sockfd + 1; i <= maxfd; ++ i) {

            if (FD_ISSET(i, &rset)) {

                char buffer[BUFFER_LENGTH] = {0};
                int ret = recv(i, buffer, BUFFER_LENGTH, 0); // 一直等待clientfd的数据，否则阻塞在这里

                if (ret == 0) {
                    close(i);
                    continue;
                }
                
                printf("accept: %d, buffer: %s\n", i, buffer);
                
                send(i, buffer, ret, 0);
                
            }
        
        }
    }
    
    //getchar();    //block

    return 0;
}

4. poll

poll(pfds, length, timeout);

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

#include <fcntl.h>
#include <pthread.h>

#include <sys/poll.h>


#define BUFFER_LENGTH        1024
#define POLL_SIZE            1024

int main() { 
    //open
    
    int sockfd = socket(AF_INET, SOCK_STREAM, 0); //io

    struct sockaddr_in servaddr;
    memset(&servaddr, 0, sizeof(struct sockaddr_in)); // 192.168.1.123
    servaddr.sin_family = AF_INET;
    servaddr.sin_addr.s_addr = htonl(INADDR_ANY); // 0.0.0.0
    servaddr.sin_port = htons(9999);

    if(-1 == bind(sockfd, (struct sockaddr*)&servaddr, sizeof(struct sockaddr))) {
        printf(" bind failed: %s", strerror(errno));
        return -1;
    }
    
    listen(sockfd, 10);        

    //sleep(10);
    
    struct sockaddr_in clientaddr;
    socklen_t len = sizeof(clientaddr);
    
/*
    struct pollfd {
        int fd;
        short events;    // 我们监测io是否可读的集合
        short revents;    // 内核反馈出来的可读的io
    }

*/
    struct pollfd fds[POLL_SIZE] = {0};

    fds[sockfd].fd = sockfd;
    fds[sockfd].events = POLLIN;

    int maxfd = sockfd;
    int clientfd = 0;

    while (1) {

        int nready = poll(fds, maxfd + 1 , -1);

        if (fds[sockfd].revents & POLLIN) {
            
            clientfd = accept(sockfd, (struct sockaddr*)&clientaddr, &len); // 有客户端连接才往下走，否则阻塞在这里
            printf("accept: %d\n", clientfd);

            fds[clientfd].fd = clientfd;
            fds[clientfd].events = POLLIN;

            if (clientfd > maxfd)    maxfd = clientfd; // 假设当前连接的fd有4 5 6 7，但是当6断开后（4 5 7），再有客户端连接会顶替6的空缺（4 5 6 7）

            if (--nready == 0)    continue;    

        }
                
        int i = 0;
        for (i = 0; i <= maxfd; ++ i) {

            if (fds[i].revents & POLLIN) {
                char buffer[BUFFER_LENGTH] = {0};
                int ret = recv(i, buffer, BUFFER_LENGTH, 0); // 一直等待clientfd的数据，否则阻塞在这里
                    
                if(ret == 0){

                    fds[i].fd = -1;
                    fds[i].events = 0;
                    
                    close(i);
                    continue;
                }

                printf("accept: %d, buffer: %s\n", i, buffer);
                
                send(i, buffer, ret, 0);
            }
        }
    }

    return 0;
}

5. epoll

epoll_create(int size);    // 在内核里创建epoll的组件

epoll_ctl(int epfd, EPOLL_OP, sockfd, event);  // 每次epoll创建完就把这个epoll加入内核，虽然增加了系统调用，但是减少了系统调用

epoll_wait(epfd, events, length, 0); // 每次只需要把有用的io从内核带出来就可以了


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

#include <fcntl.h>
#include <pthread.h>

#include <sys/poll.h>


#define BUFFER_LENGTH        1024
#define POLL_SIZE            1024

int main() { 
    //open
    
    int sockfd = socket(AF_INET, SOCK_STREAM, 0); //io

    struct sockaddr_in servaddr;
    memset(&servaddr, 0, sizeof(struct sockaddr_in)); // 192.168.1.123
    servaddr.sin_family = AF_INET;
    servaddr.sin_addr.s_addr = htonl(INADDR_ANY); // 0.0.0.0
    servaddr.sin_port = htons(9999);

    if(-1 == bind(sockfd, (struct sockaddr*)&servaddr, sizeof(struct sockaddr))) {
        printf(" bind failed: %s", strerror(errno));
        return -1;
    }
    
    listen(sockfd, 10);        

    //sleep(10);
    
    struct sockaddr_in clientaddr;
    socklen_t len = sizeof(clientaddr);
    
    int epfd = epoll_create(1);    // int size：每一次就绪总数能放多少（数组结构），3.0以后的版本改为链表结构后size就没有意义了，size>=1就行

    struct epoll_event ev;
    ev.events = EPOLLIN;
    ev.data.fd = sockfd;
    
    epoll_ctl(epfd, EPOLL_CTL_ADD, sockfd, &ev);    // key:sockfd, velue:ev,   一旦添加进来，不删除就会一直在

    struct epoll_event events[1024] = {0}; // 用来保存从内核里带出的io

    while (1) {    //mainloop

        int nready = epoll_wait(epfd, events, 1024, -1);    // -1：一直阻塞， 0：不阻塞， 1：阻塞固定时长
        if (nready < 0) continue;

        int i = 0;
        for (i = 0; i < nready; ++ i) {

            int connfd = events[i].data.fd;
        
            if (sockfd == connfd) {
                //accept默认是LT， 如果设置成ET一定要设置成非阻塞的循环
                /*
                    //ET: nonblock
                    while (clientfd < 0) {
                        clientfd = accept(listenfd, &clientaddr, &socklen);
                    }
                */
                int clientfd = accept(sockfd, (struct sockaddr*)&clientaddr, &len); // 有客户端连接才往下走，否则阻塞在这里
                if (clientfd <= 0) {
                    continue;
                }

                printf("clientfd: %d\n", clientfd);
                ev.events = EPOLLIN;    // 默认EPOLLLT：水平触发，只要数据没读完就一直读; 
                //ev.events = EPOLLIN | EPOLLET; // EPOLLET：边沿触发，只有数据发送过来时才读一次, 但是不会丢数据，他会读上次没读完的数据
                ev.data.fd = clientfd;
                epoll_ctl(epfd, EPOLL_CTL_ADD, clientfd, &ev);
            } else if (events[i].events & EPOLLIN) {

                char buffer[10] = {0};
                /*
                ET: 设置成非阻塞循环的读
                while (ret > 0) {
                    ret = recv(fd, buffer, length, 0);
                }    
                */
                //LT(默认)
                int n = recv(connfd, buffer, 10, 0);

                if (n > 0) {

                    printf("recv : %s\n", buffer);

                    send(connfd, buffer, n, 0);

                } else if (n == 0) {
                    printf("close\n");

                    epoll_ctl(epfd, EPOLL_CTL_DEL, connfd, NULL);    // 将断开的io从内核中拿走
                    close(connfd);
                }

            }
        }
    }
    return 0;
}

总结

一连接一线程：在实际场景里，一万个连接可能就几个连接在收发数据，而剩下的的线程就处于等待状态，系统开销大且浪费。
select：将需要处理的io集合拷贝进系统内核里遍历，然后将需要处理的io分成不同的集合返回。
poll：poll和select的处理方式类似，但是相比select的接口更少。
epoll：每当有一个io连接时就将其打包进系统内核，而系统内核只需要将需要事件处理的io返回即可，无需每次都将所有io集合拷贝进内核。（注意当io连接断开时，一定要将该io从内核中清除避免产生未知错误）


文章参考与<零声教育>的C/C++linux服务期高级架构系统教程学习

飞舞的代码
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
linux内核select/poll，epoll实现与区别
12-31
select，poll，epoll都是多路复用IO的函数，简单说就是在一个线程里，可以同时处理多个文件描述符的读写。 select/poll的实现很类似，epoll是从select/poll扩展而来，主要是为了解决select/poll天生的缺陷。 epoll在...
C++学习：第六章Linux高级编程 - （十一）select、TCP编程模型、Socket选项、OOB、HTTP协议
Thomas会写字
10-28 254
回顾： 多进程的问题：数据共享。 多进程的问题：进程的上下文环境(context) 文件描述符号是整数以及对应上下文环境 多进程的问题：上下文环境共享 SELECT TCP服务器编程模式 select函数 int select( int fds, //建议是监控的文件描述符号的最大值+1 fd_set *readfds, //读文件描述符号集合 //该参数既是输入，也是输出 //输入：被监控的描述符号 //输出：有数据的描述符号 fd_set *writefds, //写描述符 .
linux C/C++ socket编程
qq_37026934的博客
09-04 3636
socket
Linux socket 搭建TCP服务器（C语言）
qq_44876700的博客
02-28 895
​ TCP 是一种传输层协议，可以提供可靠的数据传输服务。它是面向连接的，具有可靠性、流量控制、拥塞控制以及双工通信的特点。​ TCP 是一种传输层协议，可以提供可靠的数据传输服务。​ 在TCP服务器中用到了六个函数socketbindlistenacceptrecv和send。​ 实现TCP服务器仅需将上述六个函数按顺序运用即可。我们还利用多线程的方法实现了一定量的并发，但是依旧存在一些问题，它是一线程一请求的形式，如果请求过多，服务器将会资源耗尽，因此无法实现大的并发量。
Linux C/C++之IO多路复用(select)
ShiXiAoLaNga的博客
04-06 3550
Linux C/C++之IO多路复用(select)
I/O多路复用【Linux/网络】（C++实现select、poll和epoll服务器）
Man9o
10-08 594
I/O 多路复用（也叫多路转接）是一种解决方案，它可以让一个进程或线程同时监控多个文件描述符（通常是网络套接字），并在其中一个或多个文件描述符准备好进行 I/O 操作时（至少一个），通知应用程序进行相应的读写操作。这样，应用程序可以在等待数据的过程中执行其他任务，而不会被阻塞，从而提高了程序的性能和响应速度。I/O 多路复用的实现方式有多种，比如 select，poll，epoll 等，它们各有优缺点，具体的选择要根据应用场景和需求来决定。
深入理解Linux网络——TCP连接建立过程（三次握手源码详解）
qq_25046827的博客
07-15 1660
icsk->icsk_accept_queue定义在inet_connection_sock下，是一个request_sock_queue类型的对象，是内核用来接收客户端请求的主要数据结构。我们平时说的全连接队列、半连接队列全都是在这个数据结构里实现的。我们来看具体的代码。// 全连接队列 struct request_sock * rskq_accept_head;// 半连接队列 struct listen_sock * listen_opt;
Linux高性能服务器编程（4）TCP协议详解
qq_53002662的博客
05-22 735
TCP协议更靠近应用层，在应用程序中有更好的可操作性。TCP模块开始发送数据时，发送缓冲区中这些等待发送的数据可能被封装成一个或多个TCP报文段发出。TCP模块发送出的TCP报文段的个数和应用程序执行的写操作次数之间没有固定的数量关系。当接收端收到多个报文段时，，TCP模块将它们携带的应用程序数据按照TCP报文段的序号依次放入TCP接受缓冲区中，并通知应用程序读取数据。接收端可以选择是否一次全读取，也可分多次读取，这取决于用户指定的应用程序缓冲区的大小。
详解Linux下TCP连接，未写完
JACKSONMHLK的博客
06-01 1280
一、服务器端最大TCP连接数 二、客户端可以发起的连接数。 三、TCP连接时，滑动窗口问题 四、TCP三次握手、四次挥手 五、TCP与UDP的区别
【Linux网络编程】select函数实现TCP并发服务器
imysy_22_的博客
10-13 1258
使用select函数来完成并发服务器
linuxC语言_用select函数或线程池两种方法制作tcp服务器[可同时接受处理多个客户端发来的指令或者处理与服务器创建新连接请求]
a812417530的博客
08-17 1201
linuxC语言_用select函数或线程池两种方法制作tcp服务器[可同时接受处理多个客户端发发来的指令。
要解决socket tcp C10K问题,传统的多线程模式和select模式都不再适用,应采用epoll,kqueue,dev_poll来捕获IO事件.zip
01-19
要解决C10K问题,传统的多线程模式和select模式都不再适用,应采用epoll,kqueue,dev_poll来捕获IO事件.zip
linux网络编程
07-11
17socket编程（十二） select限制 poll 18socket编程（十三） epoll使用 epoll与select、poll区别 epoll LT/ET模式 19socket编程（十四） UDP特点 UDP客户/服务基本模型 UDP回射客户/服务器 UDP注意点 20socket编程...
2018年C++教程网的linux网络编程视频共41集百度云下载链接.rar
04-30
epoll与select、poll区别 epoll LT/ET模式 19socket编程（十四） UDP特点 UDP客户/服务基本模型 UDP回射客户/服务器 UDP注意点 20socket编程（十五） udp聊天室实现 21socket编程（十六） UNIX域协议特点 UNIX域地址...
Linux多进程(五) 进程池 C++实现
最新发布
Lyajpunov的博客
04-26 578
进程池是一种并发编程模式，用于管理和重用多个处理任务的进程。它通常用于需要频繁创建和销毁进程的情况，以避免因此产生的开销。减少进程创建销毁的开销：避免频繁创建和销毁进程所带来的系统资源开销。提高系统响应速度：由于进程已经初始化并且一直保持在内存中，可以立即分配执行任务，减少了任务等待时间。控制资源使用：通过限制进程池中的进程数量，可以控制系统资源的使用情况，避免资源过度消耗。
Linux——web服务配置
Xinan_____的博客
04-23 1048
GET：请求获取指定资源的表示形式。使用GET方法，客户端请求服务器发送某个资源。POST：向指定资源提交数据，用于处理表单提交、文件上传等操作。PUT：向指定资源位置上传其最新内容，用于更新资源。DELETE：请求服务器删除指定资源。HEAD：请求获取与实体相对应的头部信息，用于获取资源的元数据。OPTIONS：请求查询服务器支持的HTTP方法。TRACE：请求服务器回显收到的请求消息，用于测试或诊断。200 OK：请求成功。：永久重定向，请求的资源已经被分配了新的。
linux18：进程等待
m0_73919066的博客
04-20 1095
1：子进程创建的目的是要完成父进程指派的某个任务，当子进程运行完毕退出时，父进程需要通过进程等待的方式，回收子进程资源，获取子进程退出信息（子进程有无异常？没有异常结果是否正确？检查退出码查看错误原因）2：父进程如果一直不回收，就可能造成子进程‘僵尸进程’的问题，子进程一直得不到父进程的回收，进而造成内存泄漏。3：子进程一旦变成僵尸状态，那就刀枪不入，“杀人不眨眼”的kill -9 也无能为力杀死一个已经死去的进程。只能通过进程等待将他进行回收。
Linux之C编程入门
qwertf123的博客
04-21 844
Linux之C编程入门
arm架构Linux5.0内核连接脚本文件vmlinux.lds.S分析
jianjian的博客
04-23 931
vmlinux.lds.S 是 Linux 内核中用于链接的脚本文件，用于定义内核对象文件的内存布局，即它告诉链接器如何将不同的内核代码段和数据段组合成一个最终的内核映像 vmlinux。编译内核源码生成内核文件的过程分两步，一个是“编译”，另一个是“链接”的过程，vmlinux.lds.S要做的就是告诉编译器如何链接编译好的各个内核.o文件，从而生成vmlinux文件。
tcp多线程并发服务器
05-13
TCP多线程并发服务器主要是为了提高服务器的并发处理能力，让服务器能够同时处理多个客户端的请求，提高服务器的效率。 基本实现方法如下： 1. 创建一个主线程，用于监听客户端的连接请求。 2. 当有客户端请求连接时，主线程接受连接请求，创建一个新的线程来处理该客户端的请求。 3. 在新的线程中，可以使用多路复用技术（如select、poll、epoll等）来处理来自该客户端的数据。 4. 处理完客户端的请求后，线程可以将处理结果返回给客户端，并关闭连接。 5. 主线程继续监听其他客户端的连接请求，重复上述步骤。 需要注意的是，在实现过程中需要考虑线程安全问题，避免出现线程间的竞争和死锁等问题。同时，也需要考虑服务器的负载均衡、容错处理等问题，以确保服务器的稳定性和可靠性。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值