select服务器(linux)

最新推荐文章于 2024-07-08 22:09:55 发布
最新推荐文章于 2024-07-08 22:09:55 发布
阅读量610 收藏 6
点赞数 4
文章标签： 服务器 linux 网络
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_50401606/article/details/122431196
版权

文章目录

网络的重要性

两个主机之间通信离不开网络，分布式，对数据库的操作，fpc，消息队列的组件，都离不开网络。网络主要是解决机器与机器之间通信的问题。网络有很多种方式，比如tcp、udp、广播等，网络中最重要的协议是tcp。

单线程tcp

酒店(服务器)有很多门(端口)，酒店门口有迎宾员(listenfd)，酒店中有服务员(clientfd)，酒店回来客人(客户端)，迎宾员将客人送进酒店介绍给服务员(accept)，后面一系列的服务就都由服务员来服务。有n个客户就有n个服务员。

下面是一段简单的tcp回声服务器代码：

#include <errno.h>
#include <netinet/in.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <unistd.h>
 
#define MAXLNE  4096
 
int main(int argc, char **argv) 
{
    int listenfd, connfd, n;
    struct sockaddr_in servaddr;
    char buff[MAXLNE];
 
    if ((listenfd = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
        printf("create socket error: %s(errno: %d)\n", strerror(errno), errno);
        return 0;
    }
 
    memset(&servaddr, 0, sizeof(servaddr));
    servaddr.sin_family = AF_INET;
    servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
    servaddr.sin_port = htons(9999);
 
    //指派迎宾员去哪个门口
    if (bind(listenfd, (struct sockaddr *)&servaddr, sizeof(servaddr)) == -1) {
        printf("bind socket error: %s(errno: %d)\n", strerror(errno), errno);
        return 0;
    }
    
    //开始迎宾
    if (listen(listenfd, 10) == -1) {
        printf("listen socket error: %s(errno: %d)\n", strerror(errno), errno);
        return 0;
    }
    
    //接待客人
    struct sockaddr_in client;
    socklen_t len = sizeof(client);
    if ((connfd/*产生服务员*/ = accept(listenfd, (struct sockaddr *)&client, &len)) == -1) {
        printf("accept socket error: %s(errno: %d)\n", strerror(errno), errno);
        return 0;
    }

    printf("========waiting for client's request========\n");
    while (1) {
        n = recv(connfd, buff, MAXLNE, 0);
        if (n > 0) {
            buff[n] = '\0';
            printf("recv msg from client: %s\n", buff);

	    send(connfd, buff, n, 0);
        } else if (n == 0) {
            close(connfd);
        }
        
        //close(connfd);
    }
 
    close(listenfd);
    return 0;
}

用网络调试助手去连接改服务器的时候，可以多次连接，但是只能有一个连接发送数据，服务端可以接收到呢？

首先我们要知道，在listen的时候，客户端点击连接后，就会发生tcp的三次握手，而tcp的三次握手是在内核中的协议栈中发生的，与应用层没有关系，三次握手并不发生在任何一个api中，它是协议栈本身完成的，处于listen状态时，被动完成的。进入listen状态之后，三次握手是允许的，但是，应用层并没有把这个连接拿出来去使用。accept之后会取一个连接出来使用。

将代码改成可以接收多个客户端数据

接下来要将代码改成可以有多个客户端同时发消息的代码

想法1 将accept函数放入while循环

这样会使得可以连接多个客户端，但是每个客户端只能接收一条消息
accept拿一个连接节点–> recv阻塞 -->接收数据后send–>用同一个connfd进行下一个接收

想法2 多线程

头文件：#include <pthread.h>

线程创建函数：pthread_create

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

#include <pthread.h>

#define MAXLNE 4096

void *client_routine(void *arg)
{
    int connfd = *(int *)arg;
    char buff[MAXLNE];
    while (1)
    {
        int n = recv(connfd, buff, MAXLNE, 0);
        if (n > 0)
        {
            buff[n] = '\0';
            printf("recv msg from client: %s\n", buff);

            send(connfd, buff, n, 0);
        }
        else if (n == 0)
        {
            close(connfd);
            break;
        }
    }

    return NULL;
}

int main(int argc, char **argv)
{
    int listenfd, connfd, n;
    struct sockaddr_in servaddr;
    char buff[MAXLNE];

    if ((listenfd = socket(AF_INET, SOCK_STREAM, 0)) == -1)
    {
        printf("create socket error: %s(errno: %d)\n", strerror(errno), errno);
        return 0;
    }

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

    //指派迎宾员去哪个门口
    if (bind(listenfd, (struct sockaddr *)&servaddr, sizeof(servaddr)) == -1)
    {
        printf("bind socket error: %s(errno: %d)\n", strerror(errno), errno);
        return 0;
    }

    //开始迎宾
    if (listen(listenfd, 10) == -1)
    {
        printf("listen socket error: %s(errno: %d)\n", strerror(errno), errno);
        return 0;
    }

    printf("========waiting for client's request========\n");
    while (1)
    {
        struct sockaddr_in client;
        socklen_t len = sizeof(client);
        if ((connfd /*产生服务员*/ = accept(listenfd, (struct sockaddr *)&client, &len)) == -1)
        {
            printf("accept socket error: %s(errno: %d)\n", strerror(errno), errno);
            return 0;
        }

        pthread_t threadid;
        pthread_create(&threadid, NULL, client_routine, (void*)&connfd);
    }
 
    close(listenfd);
    return 0;
}

这种服务器适合4，5个连接的场景，如会议室，但是有大量的客户端就不行了。按照posix线程标准8m来算，1G的内存，也只能连128个。内存涨到一个瓶颈的时候，系统就会重启。很难突破C10K的数量级

  1. 优点：逻辑简单
  2. 缺点：不适合大量的客户端

想法3 io多路复用组件select

当大量的客户端连进来的时候，我们并不知道要处理哪个客户端，这就需要一个组件，某个客户端发数据的时候，让我们立马可以知道这个客户端发信息来了。我们需要做的事情是，把众多的fd，放在一个组件中集中处理

相当于将一个服务员服务一个客人 变成了 让一个服务员集中处理多桌客人

fd_set rfds; //fd的集合，是一个bitset

系统提供了4个宏对描述符集进行操作：

  1. 宏FD_SET设置文件描述符集fdset中对应于文件描述符fd的位(设置为1)
  2. 宏FD_CLR清除文件描述符集fdset中对应于文件描述符fd的位（设置为0）
  3. 宏FD_ZERO清除文件描述符集fdset中的所有位(既把所有位都设置为0)。
    使用这3个宏在调用select前设置描述符屏蔽位
  4. 在调用select后使用FD_ISSET来检测文件描述符集fdset中对应于文件描述符fd的位是否被设置。

select

参考博客：https://blog.csdn.net/lingfengtengfei/article/details/12392449

int select(int __nfds, fd_set *__readfds, fd_set *__writefds, fd_set *__exceptfds, struct timeval *__timeout)

参数1：最大的fd， select中会有一个循环的操作，遍历bitmap，第一个参数就是i<n的n，所以第一个参数就是填FD_SET设置的fd中最大的fd加上1(fd是从0开始的)

select函数内部有一个置0的操作，所以在**if (FD_ISSET(i, &rset))**内要用 FD_SET宏重新置1

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

#include <pthread.h>

#define MAXLNE 4096

int main(int argc, char **argv)
{
    int listenfd, connfd, n;
    struct sockaddr_in servaddr;
    char buff[MAXLNE];

    if ((listenfd = socket(AF_INET, SOCK_STREAM, 0)) == -1)
    {
        printf("create socket error: %s(errno: %d)\n", strerror(errno), errno);
        return 0;
    }

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

    //指派迎宾员去哪个门口
    if (bind(listenfd, (struct sockaddr *)&servaddr, sizeof(servaddr)) == -1)
    {
        printf("bind socket error: %s(errno: %d)\n", strerror(errno), errno);
        return 0;
    }

    //开始迎宾
    if (listen(listenfd, 10) == -1)
    {
        printf("listen socket error: %s(errno: %d)\n", strerror(errno), errno);
        return 0;
    }

    // select
    fd_set rfds, rset;

    FD_ZERO(&rfds);
    FD_SET(listenfd, &rfds); //监控listenfd

    int max_fd = listenfd;
    while (1)
    {
        rset = rfds;
        int nready = select(max_fd + 1, &rset, NULL, NULL, NULL);
        if (FD_ISSET(listenfd, &rset))
        { //
            struct sockaddr_in client;
            socklen_t len = sizeof(client);
            if ((connfd = accept(listenfd, (struct sockaddr *)&client, &len)) == -1)
            {
                printf("accept socket error: %s(errno: %d)\n", strerror(errno), errno);
                return 0;
            }

            FD_SET(connfd, &rfds); //将新产生的连接fd加入fd_set
            if (connfd > max_fd)
                max_fd = connfd;

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

        int i = 0;
        for (i = listenfd + 1; i <= max_fd; i++)
        { //listenfd后面就是connfd，依次对connfd进行读写操作
            if (FD_ISSET(i, &rset)) 
            {
                n = recv(i, buff, MAXLNE, 0);
                if (n > 0)
                {
                    buff[n] = '\0';
                    printf("recv msg from client: %s\n", buff);

                    send(i, buff, n, 0);
                }
                else if (n == 0)
                {
                    FD_CLR(i, &rfds);
                    close(i);
                }

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

    close(listenfd);
    return 0;
}

标准send写法：

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

#include <pthread.h>

#define MAXLNE 4096

int main(int argc, char **argv)
{
    int listenfd, connfd, n;
    struct sockaddr_in servaddr;
    char buff[MAXLNE];

    if ((listenfd = socket(AF_INET, SOCK_STREAM, 0)) == -1)
    {
        printf("create socket error: %s(errno: %d)\n", strerror(errno), errno);
        return 0;
    }

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

    //指派迎宾员去哪个门口
    if (bind(listenfd, (struct sockaddr *)&servaddr, sizeof(servaddr)) == -1)
    {
        printf("bind socket error: %s(errno: %d)\n", strerror(errno), errno);
        return 0;
    }

    //开始迎宾
    if (listen(listenfd, 10) == -1)
    {
        printf("listen socket error: %s(errno: %d)\n", strerror(errno), errno);
        return 0;
    }

    // select
    fd_set rfds, rset, wfds, wset;

    FD_ZERO(&rfds);
    FD_SET(listenfd, &rfds); //监控listenfd

    FD_ZERO(&wfds);
    

    int max_fd = listenfd;
    while (1)
    {
        rset = rfds;
        wset = wfds;
        int nready = select(max_fd + 1, &rset, &wset, NULL, NULL);
        if (FD_ISSET(listenfd, &rset))
        { //
            struct sockaddr_in client;
            socklen_t len = sizeof(client);
            if ((connfd = accept(listenfd, (struct sockaddr *)&client, &len)) == -1)
            {
                printf("accept socket error: %s(errno: %d)\n", strerror(errno), errno);
                return 0;
            }

            FD_SET(connfd, &rfds); //将新产生的连接fd加入fd_set
            if (connfd > max_fd)
                max_fd = connfd;

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

        int i = 0;
        for (i = listenfd + 1; i <= max_fd; i++)
        { //listenfd后面就是connfd，依次对connfd进行读写操作
            if (FD_ISSET(i, &rset)) 
            {
                n = recv(i, buff, MAXLNE, 0);
                if (n > 0)
                {
                    buff[n] = '\0';
                    printf("recv msg from client: %s\n", buff);

                    FD_SET(i, &wfds); 
                }
                else if (n == 0)
                {
                    FD_CLR(i, &rfds);
                    printf("disconnect\n");
                    close(i);
                }

                if(--nready == 0) break;
            } else if(FD_ISSET(i, &wset)) {
                send(i, buff, n, 0);
                FD_CLR(i, &wfds);
                FD_SET(i, &rfds);
            }
        }
    }

    close(listenfd);
    return 0;
}

一个select可以支持sizeof(fd_set) * 8个fd， 多开几个select进程就可以突破C10k数量级的限制，但是突破不了C1000k数量级的限制，因为调用select的时候，会把要监控的集合copy到内核中，多个客户端可能只有几个可以操作，然后再copy出来。

_Indulge
关注
  • 4
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
select服务器
m0_63440562的博客
07-05 58
select 服务器，使用bitmap存储文件描述符进行监听IO，当监听的对象发生变化，进行置为1。
服务器搭建(TCP套接字)-select版(服务端)
知识共享，你我皆是知识的搬运工
09-19 872
select实现服务器
select并发服务器实现
kakaka666的博客
07-31 750
select()函数监视多个文件描述符，等待所监视的一个或者多个文件描述符变为“准备好”的事件状态。”准备好“状态是指：文件描述符不再是阻塞状态，可以用于某类IO操作了，包括可读，可写，发生异常三种。......
006. 基于select多路复用的服务端
a18796007675的博客
06-14 211
使用select函数完成网络通讯中，服务端程序连接多个客户端连接请求的功能。
linux下用select并发服务器
12-08
在Linux操作系统中，`select`函数是用于处理多个文件描述符（FD）就绪状态监控的一种方式，尤其在实现并发服务器时，它扮演了关键角色。`select`模型允许程序在一个时间点监视多个输入源，当其中任何一个源准备好...
Linux高性能服务器编程
05-01
《Linux高性能服务器编程》是一本深入探讨如何利用Linux操作系统特性构建高效、稳定、可扩展的服务器应用程序的专业书籍。这本书涵盖了从基础的系统调用到高级的并发处理策略，旨在帮助开发者充分利用Linux系统的...
select网络模型-Linux
11-02
在Linux操作系统中，`select`网络模型是一种古老但仍然广泛使用的I/O多路复用机制。它是编程中处理多个文件描述符（FDs）状态变化的一种方式，允许程序在一个单一的调用中等待多个文件描述符中的任何一个变为可读、...
udp_linux.rar_udp服务器 Linux
09-19
10. **并发处理**：在实际应用中，服务器可能需要处理大量并发的UDP连接，这时可以考虑使用select、poll或epoll等I/O复用技术来提高效率。 在“udp相互通信”的示例中，可能会包含客户端和服务器的实现代码，展示...
Linux服务器源码.zip
01-09
它支持多种事件模型，如epoll（Linux），kqueue（FreeBSD），poll和select，可以实现高效且低延迟的事件处理。 2. **高并发多路转接IO模型**： 这种模型是基于libevent的非阻塞I/O和多路复用技术，如epoll的水平...
SELECT实现并发服务器
05-24
SELECT实现并发服务器，TCP服务器。
select函数实现一个服务器与多个客户端的通信
12-06
利用select函数实现I/O复用，可进行一个服务器与多个客户端的通信。-CSU某课内作业
【网络】select服务器
Jasmine_yaoyao的博客
07-11 354
select服务器
Select实现并发服务器
wanna_wsl的博客
12-20 3027
并发服务器除了可以用多线程和多进程实现以外，还可以用select实现单线程并发，下面用select实现简单的示例，服务器接收客户端的连接，并将客户发的消息返回，代码如下：服务器端代码： main.c#include <sys/types.h> #include <sys/socket.h> #include <sys/time.h> #include <netinet/in.h> #include
Linux select开发服务端
luosuss的博客
03-08 1188
多路IO技术：select,同时监听多个文件描述符，将监控的操作交给内核去处理。数据类型fd_set:文件描述符集合。
select实现网络服务器
qq_26646107的博客
08-23 232
select是实现IO多路复用的一种方式，可以在同一个进程或者线程中同时监控多个文件描述符的读写状态，程序会停在select这里，直到有可以读写的文件描述符状态发生改变。select使得不用阻塞在某一个IO操作上。 在这里插入代码片 头文件 #include <sys/select.h> #include <sys/time.h> #include <sys/types.h> #include <unistd.h> int select(int nfds,
Linux C select服务器源码剖析
wwxy1995的博客
07-06 256
直接看调用主函数中while循环的部分 每次调用select都会改变FD_SET的值， 所以要两个变量，allset，以及一个rset 先看看是否有客户端请求连接，如果有处理连接。 这里用新开一个数组维护文件描述符。这样的好处是如果用动态数组，可以动态维护文件描述符。 遍历整个客户端的数组，然后来看看有没有可以读的信息 select函数的缺点是每次要将FD_SET拷贝到内核区，是...
【Linux】进程间通信——匿名管道
最新发布
2201_76024104的博客
07-08 1148
1.：一个进程需要将它的数据发送给另一个进程，比如我们有两个进程，一个负责获取数据，另一个负责处理数据，这时第一个进程就要将获取到的数据交给第二个进程2.：多个进程间共享同样的资源3.：一个进程需要给其他进程发送消息，通知他们发生了某种事件4.：有些事件需要完全控制另一个进程，比如我们在使用gdb调试时，gdb就是一个进程，它控制了我们要调试的进程进程之前是有互相传递信息的需求，但是，一个进程不可能去另一个进程的地址空间中取信息，所以这就要求操作系统去提供一块交换数据的空间来供进程之间使用。
linux高级编程，tcp服务器select模式
06-06
TCP服务器使用select模式可以实现同时处理多个客户端的连接请求，以下是一些select模式的实现步骤： 1. 创建监听socket，并将其加入到select的监听列表中。 2. 创建一个文件描述符集合，将监听socket加入到集合中。...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值