Socket编程之TCP并发服务器

已于 2023-03-05 17:48:49 修改
阅读量952 收藏 6
点赞数 2
分类专栏： 网络编程 文章标签： 服务器 tcp/ip 网络 websocket
于 2023-03-05 17:38:36 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Little_Star0/article/details/129347635
版权

目录

一、服务器模型

二、TCP并发服务器

2.1使用多线程实现TCP并发服务器

2.2使用多进程实现TCP并发服务器

2.3使用多路IO复用实现TCP并发服务器

三、select、setsockopt/getsockopt函数说明

3.1 selsct函数说明：

3.2关于selset函数的几个问题

3.3setsockopt/getsockopt函数说明

一、服务器模型

        服务器模型分为两种：循环服务器、并发服务器

        循环服务器：在同一个时刻只能响应一个客户端的请求。

        并发服务器：在同一时刻可以响应多个客户端的请求。

TCP服务器默认就是一个循环服务器，受两类阻塞函数accept和recv之间的影响。

UDP服务器默认就是一个并发服务器，因为只有一个会造成阻塞的函数（recvfrom）。

二、TCP并发服务器

        在有些场景下我们即需要保证数据可靠，又需要支持并发，这样就需要用到TCP并发服务器了。

2.1使用多线程实现TCP并发服务器

思路：主线程负责accept等待客户端连接，一旦有客户端连接就创建一个子线程专门用于和当前的客户端通信。

服务器代码：

#include <arpa/inet.h>
#include <errno.h>
#include <error.h>
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#define PRINT_ERR(msg)                                      \
    do {                                                    \
        printf("%s %s:%d\n", __FILE__, __func__, __LINE__); \
        perror(msg);                                        \
        return -1;                                          \
    } while (0)
typedef struct MSG {
    char txt[128];
    int acceptfd;
    struct sockaddr_in clientaddr;
} msg_t;

// 线程体
void* deal_read_write(void* arg)
{
    pthread_detach(pthread_self()); // 将线程设置成被动分离状态
    msg_t buff = *(msg_t*)arg;
    // 定义结构体保存客户端信息
    int nbytes = 0; // 记录recv函数的返回值
    int acceptfd;
    struct sockaddr_in clientaddr;
    memset(&clientaddr, 0, sizeof(clientaddr));
    socklen_t clientaddr_len = sizeof(clientaddr);
    acceptfd = buff.acceptfd;
    clientaddr = buff.clientaddr;
    while (1) {
        // 收发数据
        memset(&buff, 0, sizeof(buff));
        if (-1 == (nbytes = recv(acceptfd, &buff, sizeof(buff), 0))) {
            perror("recv error");
            printf("%s %s:%d\n", __FILE__, __func__, __LINE__);
            pthread_exit(EXIT_FAILURE);
        } else if (0 == nbytes) {
            printf("客户端[%s:%d]断开了连接..\n", inet_ntoa(clientaddr.sin_addr), ntohs(clientaddr.sin_port));
            break;
        }
        if (!strcmp(buff.txt, "quit")) {
            printf("客户端[%s:%d]退出了..\n", inet_ntoa(clientaddr.sin_addr), ntohs(clientaddr.sin_port));
            break;
        }
        printf("[%s:%d]:[%s]\n", inet_ntoa(clientaddr.sin_addr), ntohs(clientaddr.sin_port), buff.txt);

        // 组装应答回复客户端
        strcat(buff.txt, "--server");
        if (-1 == send(acceptfd, &buff, sizeof(buff), 0)) {
            perror("send error");
            printf("%s %s:%d\n", __FILE__, __func__, __LINE__);
            pthread_exit(EXIT_FAILURE);
        }
    }

    close(acceptfd);
    pthread_exit(EXIT_SUCCESS);
}

int main(int argc, const char* argv[])
{
    // 入参合理性检查
    if (3 != argc) {
        printf("Usage : %s <ip> <port>\n", argv[0]);
        exit(-1);
    }

    // 1.创建套接字
    int sockfd = socket(AF_INET, SOCK_STREAM, 0);
    if (-1 == sockfd) {
        PRINT_ERR("socket error");
    }

    // 2.填充服务器网络信息结构体
    struct sockaddr_in serveraddr;
    memset(&serveraddr, 0, sizeof(serveraddr));
    serveraddr.sin_family = AF_INET;
    serveraddr.sin_port = htons(atoi(argv[2]));
    serveraddr.sin_addr.s_addr = inet_addr(argv[1]);
    socklen_t serveraddr_len = sizeof(serveraddr);

    // 设置端口复用
    int flag = 1;
    if (-1 == setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &flag, sizeof(flag))) {
        printf("setsockopt error");
    }

    // 3.将套接字与服务器的网络信息结构体绑定
    if (-1 == bind(sockfd, (struct sockaddr*)&serveraddr, serveraddr_len)) {
        PRINT_ERR("bind error");
    }

    // 4.将套接字设置成被动监听状态
    if (-1 == listen(sockfd, 5)) {
        PRINT_ERR("listen error");
    }

    // 定义结构体保存客户端信息
    struct sockaddr_in clientaddr;
    memset(&clientaddr, 0, sizeof(clientaddr));
    socklen_t clientaddr_len = sizeof(clientaddr);

    int nbytes = 0;
    msg_t buff;
    // 5.阻塞等待客户端连接
    pthread_t tid;
    int acceptfd = 0;
    int fd = 0;
    char file[128] = { 0 };
    while (1) {
        // 主线程收发数据
        printf("正在等待客户端连接..\n");
        if (-1 == (acceptfd = accept(sockfd, (struct sockaddr*)&clientaddr, &clientaddr_len))) {
            PRINT_ERR("accept error");
        }
        printf("客户端[%s:%d]连接到服务器..\n", inet_ntoa(clientaddr.sin_addr), ntohs(clientaddr.sin_port));
        buff.acceptfd = acceptfd;
        buff.clientaddr = clientaddr;
        // 创建子线程
        if ((errno = pthread_create(&tid, NULL, deal_read_write, (void*)&buff)) != 0)
            PRINT_ERR("pthread create error");
    }
    // 关闭套接字
    close(sockfd);

    return 0;
}

客户端代码：

#include <arpa/inet.h>
#include <errno.h>
#include <error.h>
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#define PRINT_ERR(msg)                                      \
    do {                                                    \
        printf("%s %s:%d\n", __FILE__, __func__, __LINE__); \
        perror(msg);                                        \
        return -1;                                          \
    } while (0)
typedef struct MSG {
    char txt[128];
    int acceptfd;
    struct sockaddr_in clientaddr;
} msg_t;

int main(int argc, const char* argv[])
{
    // 入参合理性检查
    if (3 != argc) {
        printf("Usage : %s <ip> <port>\n", argv[0]);
        exit(-1);
    }
    // 1.创建流式套接字
    int sockfd = socket(AF_INET, SOCK_STREAM, 0);
    if (-1 == sockfd) {
        PRINT_ERR("socket error");
    }

    // 2.填充服务器网络信息结构体
    struct sockaddr_in serveraddr;
    memset(&serveraddr, 0, sizeof(serveraddr));
    serveraddr.sin_family = AF_INET;    //ipv4协议
    serveraddr.sin_port = htons(atoi(argv[2]));
    serveraddr.sin_addr.s_addr = inet_addr(argv[1]);
    socklen_t serveraddr_len = sizeof(serveraddr);

    // 3.与服务器建立连接
    if (-1 == connect(sockfd, (struct sockaddr*)&serveraddr, serveraddr_len)) {
        PRINT_ERR("connect error");
    }
    printf("与服务器连接成功..\n");

    // 收发数据
    msg_t buff;
    int fd, ret = 0;
    while (1) {
        //从终端读取需要发送的消息
        memset(&buff, 0, sizeof(buff));
        fgets(buff.txt, 128, stdin);
        buff.txt[strlen(buff.txt) - 1] = '\0';
        if (!strcmp(buff.txt, "quit"))
            break;
        // 发送数据
        if (-1 == send(sockfd, &buff, sizeof(buff), 0))
            PRINT_ERR("send error");
        // 接收应答消息
        memset(&buff, 0, sizeof(buff));
        if (-1 == recv(sockfd, &buff, sizeof(buff), 0))
            PRINT_ERR("recv error");
        printf("server:[%s]\n",buff.txt);   //打印服务器消息

    }

    // 关闭套接字
    close(sockfd);

    return 0;
}

makefile：

all:server client

server:server.o
	gcc $^ -o $@ -lpthread
client:client.o
	gcc $^ -o $@ -lpthread
%.o:%.c
	gcc -c $^ -o $@	-lpthread
clean:
	rm server client *.o

2.2使用多进程实现TCP并发服务器

思路：父进程负责accept等待客户端连接，一旦有客户端连接就创建一个子进程专门用于和当前的客户端通信。

服务器代码：

#include <arpa/inet.h>
#include <errno.h>
#include <error.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>
#include <signal.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#define PRINT_ERR(msg)                                      \
    do {                                                    \
        printf("%s %s:%d\n", __FILE__, __func__, __LINE__); \
        perror(msg);                                        \
        return -1;                                          \
    } while (0)
typedef struct MSG {
    char txt[128];
    int acceptfd;
    struct sockaddr_in clientaddr;
} msg_t;

// 信号处理函数
void sig_function(int signo)
{
    if (SIGUSR1 == signo) {
        wait(NULL); // 不关心子进程exit的返回值
    }
}

int main(int argc, const char* argv[])
{
    // 入参合理性检查
    if (3 != argc) {
        printf("Usage : %s <ip> <port>\n", argv[0]);
        exit(-1);
    }

    // 1.创建套接字
    int sockfd = socket(AF_INET, SOCK_STREAM, 0);
    if (-1 == sockfd) {
        PRINT_ERR("socket error");
    }

    // 2.填充服务器网络信息结构体
    struct sockaddr_in serveraddr;
    memset(&serveraddr, 0, sizeof(serveraddr));
    serveraddr.sin_family = AF_INET; // ipv4协议
    serveraddr.sin_port = htons(atoi(argv[2]));
    serveraddr.sin_addr.s_addr = inet_addr(argv[1]);
    socklen_t serveraddr_len = sizeof(serveraddr);

    // 设置端口复用
    int flag = 1;
    if (-1 == setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &flag, sizeof(flag))) {
        printf("setsockopt error");
    }

    // 3.将套接字与服务器的网络信息结构体绑定
    if (-1 == bind(sockfd, (struct sockaddr*)&serveraddr, serveraddr_len)) {
        PRINT_ERR("bind error");
    }

    // 4.将套接字设置成被动监听状态
    if (-1 == listen(sockfd, 5)) {
        PRINT_ERR("listen error");
    }

    // 定义结构体保存客户端信息
    struct sockaddr_in clientaddr;
    memset(&clientaddr, 0, sizeof(clientaddr));
    socklen_t clientaddr_len = sizeof(clientaddr);

    int pid;
    msg_t buff;
    int nbytes = 0;
    int acceptfd = 0;

    // 使用signal函数回收子进程资源
    signal(SIGUSR1, sig_function);

    // 5.阻塞等待客户端连接
    while (1) {
        // 主程收发数据
        printf("正在等待客户端连接..\n");
        if (-1 == (acceptfd = accept(sockfd, (struct sockaddr*)&clientaddr, &clientaddr_len))) {
            PRINT_ERR("accept error");
        }
        printf("客户端[%s:%d]连接到服务器..\n", inet_ntoa(clientaddr.sin_addr), ntohs(clientaddr.sin_port));
        buff.acceptfd = acceptfd;
        buff.clientaddr = clientaddr;

        // 创建子进程
        pid = fork();
        if (-1 == pid) {
            PRINT_ERR("fork error");
        } else if (0 == pid) {
            // 子进程
            while (1) {
                // 收发数据
                memset(&buff, 0, sizeof(buff));
                if (-1 == (nbytes = recv(acceptfd, &buff, sizeof(buff), 0))) {
                    PRINT_ERR("recv error");
                } else if (0 == nbytes) {
                    printf("客户端[%s:%d]断开了连接..\n", inet_ntoa(clientaddr.sin_addr), ntohs(clientaddr.sin_port));
                    break;
                }
                if (!strcmp(buff.txt, "quit")) {
                    printf("客户端[%s:%d]退出了..\n", inet_ntoa(clientaddr.sin_addr), ntohs(clientaddr.sin_port));
                    break;
                }
                printf("[%s:%d]:[%s]\n", inet_ntoa(clientaddr.sin_addr), ntohs(clientaddr.sin_port), buff.txt);

                // 给客户端回消息
                strcat(buff.txt, "--server");
                if (-1 == send(acceptfd, &buff, sizeof(buff), 0)) {
                    PRINT_ERR("send error");
                }
            }
            // 给父进程发送子进程退出的信号
            kill(getppid(), SIGUSR1);
            close(acceptfd);
            exit(EXIT_SUCCESS); // 子进程退出
        } else {

            close(acceptfd);
        }
    }
    // 关闭套接字
    close(sockfd);

    return 0;
}

客户端代码：

#include <arpa/inet.h>
#include <errno.h>
#include <error.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>
#include <signal.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#define PRINT_ERR(msg)                                      \
    do {                                                    \
        printf("%s %s:%d\n", __FILE__, __func__, __LINE__); \
        perror(msg);                                        \
        return -1;                                          \
    } while (0)
typedef struct MSG {
    char txt[128];
    int acceptfd;
    struct sockaddr_in clientaddr;
} msg_t;

int main(int argc, const char* argv[])
{
    // 入参合理性检查
    if (3 != argc) {
        printf("Usage : %s <ip> <port>\n", argv[0]);
        exit(-1);
    }
    // 1.创建流式套接字
    int sockfd = socket(AF_INET, SOCK_STREAM, 0);
    if (-1 == sockfd) {
        PRINT_ERR("socket error");
    }

    // 2.填充服务器网络信息结构体
    struct sockaddr_in serveraddr;
    memset(&serveraddr, 0, sizeof(serveraddr));
    serveraddr.sin_family = AF_INET;
    serveraddr.sin_port = htons(atoi(argv[2]));
    serveraddr.sin_addr.s_addr = inet_addr(argv[1]);
    socklen_t serveraddr_len = sizeof(serveraddr);

    // 3.与服务器建立连接
    if (-1 == connect(sockfd, (struct sockaddr*)&serveraddr, serveraddr_len)) {
        PRINT_ERR("connect error");
    }
    printf("与服务器连接成功..\n");

    // 收发数据
    msg_t buff;
    int fd, ret = 0;
    while (1) {
        memset(&buff, 0, sizeof(buff));
        fgets(buff.txt, 128, stdin);
        buff.txt[strlen(buff.txt) - 1] = '\0';
        if (!strcmp(buff.txt, "quit"))
            break;
        // 发送数据
        if (-1 == send(sockfd, &buff, sizeof(buff), 0))
            PRINT_ERR("send error");
        // 接收应答消息
        memset(&buff, 0, sizeof(buff));
        if (-1 == recv(sockfd, &buff, sizeof(buff), 0))
            PRINT_ERR("recv error");
        printf("server:[%s]\n",buff.txt);

    }

    // 关闭套接字
    close(sockfd);

    return 0;
}

makefile：

all:server client

server:server.o
	gcc $^ -o $@
client:client.o
	gcc $^ -o $@
%.o:%.c
	gcc -c $^ -o $@
clean:
	rm server client *.o

2.3使用多路IO复用实现TCP并发服务器

思路：TCP服务中有两类阻塞函数（recv和accept）是造成TCP无法并发的罪魁祸首，其本质就是sockfd和acceptfd之间的影响，只要解决了这两类文件描述符之间的相互影响就解决了TCP并发的问题，我们可以使用多路IO复用来解决这个问题。

多路IO复用基本思想：构造一个关于文件描述符的表，将要监视的文件描述符都放在这个表里，将这表交给一个函数 (select poll epoll)，这个函数默认也是阻塞的，当监视的文件描述符中，有一个或多个准备就绪的时候，这个函数会返回，返回的时候会通知我们哪些文件描述符准备就绪可以进行IO操作了我们再去执行相应的IO操作 就不会阻塞了。

服务器代码：

#include <stdio.h>
#include <string.h>
#include <sys/socket.h>
#include <sys/time.h>
#include <sys/types.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <sys/wait.h>
#include <stdlib.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#define PRINT_ERR(msg)                                      \
    do {                                                    \
        printf("%s %s:%d\n", __FILE__, __func__, __LINE__); \
        perror(msg);                                        \
        return -1;                                          \
    } while (0)
typedef struct MSG {
    char txt[128];
    int acceptfd;
    struct sockaddr_in clientaddr;
} msg_t;

int main(int argc, const char* argv[])
{
    // 入参合理性检查
    if (3 != argc) {
        printf("Usage : %s <ip> <port>\n", argv[0]);
        exit(-1);
    }

    // 1.创建套接字
    int sockfd = socket(AF_INET, SOCK_STREAM, 0);
    if (-1 == sockfd) {
        PRINT_ERR("socket error");
    }

    // 2.填充服务器网络信息结构体
    struct sockaddr_in serveraddr;
    memset(&serveraddr, 0, sizeof(serveraddr));
    serveraddr.sin_family = AF_INET;
    serveraddr.sin_port = htons(atoi(argv[2]));
    serveraddr.sin_addr.s_addr = inet_addr(argv[1]);
    socklen_t serveraddr_len = sizeof(serveraddr);

    // 设置端口复用
    int flag = 1;
    if (-1 == setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &flag, sizeof(flag))) {
        printf("setsockopt error");
    }

    // 3.将套接字与服务器的网络信息结构体绑定
    if (-1 == bind(sockfd, (struct sockaddr*)&serveraddr, serveraddr_len)) {
        PRINT_ERR("bind error");
    }

    // 4.将套接字设置成被动监听状态
    if (-1 == listen(sockfd, 5)) {
        PRINT_ERR("listen error");
    }

    // 创建监视文件描述符的集合
    fd_set rfds; // 母本
    fd_set rfds_temp; // 副本
    int max_fd = 0; // 最大文件描述符

    FD_ZERO(&rfds);
    FD_ZERO(&rfds_temp);
    FD_SET(sockfd, &rfds); // 将套接字添加到需要监视的文件描述符集中
    max_fd = max_fd > sockfd ? max_fd : sockfd; // 更新最大文件描述符

    msg_t buff;
    int ret = 0, i = 0, nbytes = 0;
    int acceptfd = 0;

     定义结构体保存客户端信息（如果需要给指定客户端回复需要保存信息，会用到MSG结构体第三个参数）
    // struct sockaddr_in clientaddr;
    // memset(&clientaddr, 0, sizeof(clientaddr));
    // socklen_t clientaddr_len = sizeof(clientaddr);

    // 5.阻塞等待客户端连接
    while (1) {
        rfds_temp = rfds; // 每次调用select函数都需要提前重置一下副本
        if (-1 == (ret = select(max_fd + 1, &rfds_temp, NULL, NULL, NULL)))
            PRINT_ERR("select error");
        for (i = 3; i < max_fd + 1 && ret != 0; i++) {
            // 遍历判断哪一个文件描述符处于活跃状态
            if (FD_ISSET(i, &rfds_temp)) {
                if (i == sockfd) { // 有新的客户端连接
                    if (-1 == (acceptfd = accept(i, NULL, NULL)))
                        PRINT_ERR("accept error");
                    printf("[%d]客户端连接到服务器\n", acceptfd);
                    // 将新的文件描述符添加到监视集合中（母本中）
                    FD_SET(acceptfd, &rfds);
                    max_fd = max_fd > acceptfd ? max_fd : acceptfd; // 更新最大文件描述符
                } else { // 有客户端发来消息
                    memset(&buff, 0, sizeof(buff));
                    if (-1 == (nbytes = recv(i, &buff, sizeof(buff), 0))) {
                        PRINT_ERR("recv error");
                    }
                    // 处理客户端异常退出
                    if (0 == nbytes) {
                        printf("客户端[%d]断开了连接..\n", i);
                        FD_CLR(i, &rfds);
                        close(i);
                        continue;
                    }
                    // 处理客户端主动退出
                    if (!strcmp(buff.txt, "quit")) {
                        printf("客户端[%d]退出了..\n", i);
                        FD_CLR(i, &rfds);
                        close(i);
                        continue;
                    }
                    printf("[%d]:[%s]\n", i, buff.txt);
                    // 给客户端组装应答消息
                    strcat(buff.txt, "--😀");
                    if (-1 == send(i, &buff, sizeof(buff), 0)) {
                        PRINT_ERR("send error");
                    }
                }
                ret--;
            }
        }
    }
    // 关闭套接字
    close(sockfd);

    return 0;
}

客户端代码：

#include <stdio.h>
#include <string.h>
#include <sys/socket.h>
#include <sys/time.h>
#include <sys/types.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <sys/wait.h>
#include <stdlib.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#define PRINT_ERR(msg)                                      \
    do {                                                    \
        printf("%s %s:%d\n", __FILE__, __func__, __LINE__); \
        perror(msg);                                        \
        return -1;                                          \
    } while (0)
typedef struct MSG {
    char txt[128];
    int acceptfd;
    struct sockaddr_in clientaddr;
} msg_t;

int main(int argc, const char* argv[])
{
    // 入参合理性检查
    if (3 != argc) {
        printf("Usage : %s <ip> <port>\n", argv[0]);
        exit(-1);
    }
    // 1.创建流式套接字
    int sockfd = socket(AF_INET, SOCK_STREAM, 0);
    if (-1 == sockfd) {
        PRINT_ERR("socket error");
    }

    // 2.填充服务器网络信息结构体
    struct sockaddr_in serveraddr;
    memset(&serveraddr, 0, sizeof(serveraddr));
    serveraddr.sin_family = AF_INET;    //ipv4协议
    serveraddr.sin_port = htons(atoi(argv[2]));
    serveraddr.sin_addr.s_addr = inet_addr(argv[1]);
    socklen_t serveraddr_len = sizeof(serveraddr);

    // 3.与服务器建立连接
    if (-1 == connect(sockfd, (struct sockaddr*)&serveraddr, serveraddr_len)) {
        PRINT_ERR("connect error");
    }
    printf("与服务器连接成功..\n");

    // 收发数据
    msg_t buff;
    int fd, ret = 0;
    while (1) {
        memset(&buff, 0, sizeof(buff));
        fgets(buff.txt, 128, stdin);
        buff.txt[strlen(buff.txt) - 1] = '\0';
        // 发送数据
        if (-1 == send(sockfd, &buff, sizeof(buff), 0))
            PRINT_ERR("send error");
        if (!strcmp(buff.txt, "quit"))
            break;
        // 接收应答消息
        memset(&buff, 0, sizeof(buff));
        if (-1 == recv(sockfd, &buff, sizeof(buff), 0))
            PRINT_ERR("recv error");

        printf("server:[%s]\n", buff.txt);  //打印服务器消息
    }

    // 关闭套接字
    close(sockfd);

    return 0;
}

makefile：

all:server client

server:server.o
	gcc $^ -o $@
client:client.o
	gcc $^ -o $@
%.o:%.c
	gcc -c $^ -o $@
clean:
	rm server client *.o

三、select、setsockopt/getsockopt函数说明

3.1 selsct函数说明：

功能：
	实现多路IO复用
头文件：
	#include <sys/select.h>
函数原型：
	int select(int nfds, fd_set *readfds, fd_set *writefds,
                  fd_set *exceptfds, struct timeval *timeout);
参数：
    nfds：		要监视的最大的文件描述符 +1
	readfds：	要监视的读文件描述符集合 如果不关心 可以传NULL
	writefds：	要监视的写文件描述符集合 如果不关心 可以传NULL
	exceptfds：	要监视的异常文件描述符集合 如果不关心 可以传NULL
	timeout：	超时时间 如果传 NULL 则永久阻塞
返回值：
	成功  就绪的文件描述符的个数
	超时  0
	失败  -1  重置错误码  
	
四个宏函数：
	void FD_CLR(int fd, fd_set *set);	//将文件描述符在集合中删除
	int  FD_ISSET(int fd, fd_set *set);	//测试文件描述符是否还在集合中
										// 返回0 不在   返回非0 还在
	void FD_SET(int fd, fd_set *set);	//将文件描述符添加到集合中
	void FD_ZERO(fd_set *set);			//清空文件描述符集合

注意事项：
	1.select只能用来监视小于 FD_SETSIZE 1024 的文件描述符，poll没有这个限制
	2.select每次返回都会将没有就绪的文件描述符在集合中擦除
		因此在循环中每次调用select之前，都要重置集合
	3.大部分场景下我们只关心读文件描述符集合 readfds

3.2关于selset函数的几个问题

1.select函数fd_set集合的本质及为什么要限制最大文件描述符：
    因为select函数的作用是为了设置或者获取文件描述符的状态;
    文件描述符的状态只有就绪和非就绪两个状态，
    所以在集合中我们首先需要保存这两个状态；
    其次select函数可以同时监视多个文件描述符，
    所以在集合中我们也需要保存不同的文件描述符；
    为了节省空间我们用一个比特位的0和1来表示文件描述符的状态，用不同的比特位来表示不同的文件，
    所以要监视的文件描述符的集合是一个long int xxx[16]的数组；
    通过不同的比特位来表示不同文件描述符（[0~1023]一共1024位），
    通过每个比特位的0和1来表示文件描述符的状态。

2.select返回值有什么用？
    select函数返回的是就绪的文件描述符的个数，
    在调用select函数的整个循环过程中，select函数调用之后我们需要对就绪的文件描述符进行IO处理
    如果已知就绪的文件描述符的个数，在遍历所有IO处理的过程中就可以减少遍历的个数，
    判断的时候没必要从第一个文件描述符一直判断到最后一个文件描述符

3.select函数对应的四个宏函数的原理。
    本质都是位运算
    void FD_CLR(int fd, fd_set *set);    //将文件描述符在集合中删除
        也就是将个比特位置零（置为非就绪）

    int  FD_ISSET(int fd, fd_set *set);    //测试文件描述符是否还在集合中
                                                                // 返回0 不在   返回非0 还在
        判断某一个比特位是否为1（是否为就绪态）

    void FD_SET(int fd, fd_set *set);    //将文件描述符添加到集合中
        将某一位的比特位置1（设置为就绪态）

    void FD_ZERO(fd_set *set);            //清空文件描述符集合
        将整个文件描述符集合置零（都为非就绪态）

4.为什么select参数中表示最大文件描述符的参数要+1.
    因为在select函数中判断某一个比特位是否为1（判断哪个进程为就绪态）使用了类似for循环的方式
    for(i = 0, i < nfds; i++)...要想把每一位都遍历到，需要让nfds+1

5.为什么每次调用select函数中文件描述符的集合都要重置。
    因为每一次select函数调用完毕都会将传入的文件描述符集合中没有就绪的文件描述符置零
    所以在每次循环判断各个文件描述符的状态之前都要将文件描述符的集合重置
 

3.3setsockopt/getsockopt函数说明

功能：
	设置或者获取套接字的属性
头文件：
	#include <sys/types.h>
	#include <sys/socket.h>
函数原型：
	int getsockopt(int sockfd, int level, int optname,
				  void *optval, socklen_t *optlen);
	int setsockopt(int sockfd, int level, int optname,
				  const void *optval, socklen_t optlen);
参数：
	sockfd：要操作的套接字
	level：	选项的级别
			套接字API级别	SOL_SOCKET
			TCP级别			IPPROTO_TCP
			IP级别			IPPROTO_IP
	optname：选项的名字  不同的选项在不同的级别中
			套接字API级别：
				SO_BROADCAST	是否允许发送广播
				SO_RCVBUF		接收缓冲区大小
				SO_SNDBUF		发送缓冲区大小
				SO_RCVTIMEO		接收超时时间
				SO_SNDTIMEO		发送超时时间
					使用 struct timeval 结构体
					如果超时返回-1 错误码置为 EAGAIN
				SO_REUSEADDR	是否允许端口复用
			TCP级别：
				TCP_NODELAY		设置关闭nagle算法
			IP级别：
				IP_ADD_MEMBERSHIP	设置加入多播组
	optval：选项的值
	optlen：optval的大小
返回值：
	成功  0
	失败  -1  重置错误码
枸杞桑葚菊花茶
关注
  • 2
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
基于TCP的Socket编程
qq_41141896的博客
06-06 6580
     TCP/IP(Transmission Control Protocol/Internet Protocol) 即传输控制协议/网间协议，是一种面向连接（连接导向）的、可靠的、基于字节流的运输层（Transport layer）通信协议。在使用TCP协议传输数据，接收端收到的是一个和发送端完全一样的数据流。发送端和接收端必须建立联系，以便在TCP协议基础上进行通讯，其端口之间建立连接，一...
socket编程之简单的TCP服务器
LeetCode8023的博客
08-06 5517
一、socket编程 socket编程socket这个词可以表示很多概念: 在TCP/IP协议中,“IP地址+TCP或UDP端口号”唯一标识网络通讯中的一个进程,“IP地址+端口号”就称为socket。 在TCP协议中,建立连接的两个进程各自有一个socket来标识,那么这两个socket组成 的socketpair就唯一标识一个连接。socket本身有“插座”的意思,因此用来描述网络连接的一
linux 网络编程:使用两线程实现socket同时收发数据
热门推荐
Biao
09-26 1万+
工作中最近有使用到socket 向客户端同时发送和接收数据，因为是嵌入式linux设备，且要求只能同时一个客户端连接该端口。考虑到节省系统资源，只创建了两个线程分别实现服务端的收发数据。下面直接上代码，该代码为在PC机上程序，已作详细注释。 server.c #include #include #include #include #include #include #include #incl...
基于TCP的Socket编程--多线程群聊
qq_42404383的博客
03-08 1257
Windows系统下基于TCP的Sockets编程 一、前情提要 what’s TCP? 传输控制协议（TCP，Transmission Control Protocol）是一种面向连接的、可靠的、基于字节流的传输层通信协议，由IETF的RFC 793 [1] 定义。 TCP旨在适应支持多网络应用的分层协议层次结构。 连接到不同但互连的计算机通信网络的主计算机中的成对进程之间依靠TCP提供可靠的通...
TCP 通信并发服务器详解（附有案例代码）
热爱数据库的小胖
07-20 2540
代码】TCP通信并发详解（附有案例代码）
实现TCP并发服务器
weixin_47783699的博客
11-25 2545
详解实现TCP并发服务器两种方法:1、使用多进程实现TCP并发服务器2、使用多线程实现TCP并发服务器。
socket套接字编程---TCP通信流程和代码编写（多线程&多进程）
S5242的博客
04-07 4046
文章目录TCP通信流程TCP通信接口认识：TCP服务端和客户端通信代码：多进程TCP通信多线程TCP通信 TCP（传输控制协议）特点：面向链接，可靠传输，面向字节流。 应用于安全性要求大于实时性的场景，如文件传输 五元组：源端IP和port，对端IP和port，协议；（sip+sport+dip+dport+proto） TCP通信流程 Server端： 创建套接字： 在内核中创建socket结构体 为套接字绑定地址信息—描述socket结构。 给创建的socket结构绑定源端IP和端口，协议 作用
TCP socket 多线程
weixin_44815745的博客
09-16 128
TCP Socket 编程 实现 多线程
socket编程之并发服务器连接代码
11-18
在IT领域，Socket编程是构建网络通信应用的基础，特别是在TCP/IP协议栈中。TCP（传输控制协议）是一种面向连接的、可靠的、基于...理解并发服务器的工作原理和Socket编程技巧，对于开发高效、稳定的网络服务至关重要。
基于TCP的Socket编程服务器和客户端代码
06-14
本主题聚焦于使用Java进行基于TCP的Socket编程，通过`File_client.java`和`File_server.java`两个文件来实现服务器和客户端之间的数据交换。 首先，TCP Socket编程的基础是Java的`java.net.Socket`和`java.net....
Linux网络编程-网络基础-socket编程-高并发服务器.pdf
09-05
【Linux网络编程-网络基础-socket编程-高并发服务器】 在深入探讨Linux下的网络编程之前，我们首先要理解网络通信的基础概念——协议。协议是数据传输和解释的规则，它确保了不同设备之间的通信能顺利进行。例如，...
Socket编程利用TCP协议的实验报告.doc
11-19
在本实验报告中，我们将探讨如何使用C++进行TCP协议下的Socket编程。 实验目的主要在于通过实际操作，掌握TCP协议的编程方法，包括客户端与服务器端的通信流程。TCP协议的主要特点是三次握手建立连接，确保数据的...
STM32 TCP并发服务器源码（可与多个客户端通信）
07-09
TCP并发服务器源码则是实现STM32设备作为服务器，能够同时处理多个客户端连接请求的软件设计。在这个项目中，STM32将作为服务器端，通过TCP/IP协议栈接收并响应来自多个客户端的通信请求。 TCP（传输控制协议）是一...
TCP并发服务器
weixin_64965464的博客
12-25 724
【代码】TCP并发服务器。
Socket通信实现一个服务器端接收多个客户端的数据
weixin_41786712的博客
03-24 6830
需求： 一个服务器端同时接收多个客户端的数据。 分析： 服务器端每接收一次Socket管道，就分配一个独立的线程来处理客户端发送的数据，便能实现一个服务器端接收多个客户端的数据。 客户端开发流程: 1.创建客户端Socket对象，输入服务器的IP和端口号，请求连接服务器端； 2.通过Socket管道得到一个字节输出流； 3.通过字节输出流输出数据到服务器端。 public class Client...
【项目】— 基于TCP的高并发聊天系统
weixin_54428357的博客
08-30 489
基于TCP的高并发聊天系统
多线程的TCP协议服务端实现 socketserver（包含粘包详解）
weixin_47175709的博客
01-12 636
多线程服务端、粘包处理
socket编程：多线程建立一对多的tcp服务
wch0001的博客
08-18 5385
文章目录前言编程模式编程步骤一对一的TCP服务一对多的TCP服务 前言 因为编程需要，需要将tcp服务增加到软件中进行本地测试，所以开始学习socket编程，首先需要了解socket相关的知识。本文只摘录编程中最先需要了解的内容，详细请参考以下两个博客: https://blog.csdn.net/xiaoquantouer/article/details/58001960 https://www.cnblogs.com/helloworldcode/p/10610581.html sockets（套接字）
两台低功耗服务器存档
最新发布
skywalk8163的专栏
07-23 540
两台都是J1900 四核芯片，当前1号机内存8G，2号机内存4G后将2号机内存升为8G，使用的协德牌子的内存。
TCP/IP Socket网络编程与并发服务器详解
"并发服务器-socket网络编程"涉及的知识点涵盖了Internet历史、TCP/IP协议原理、Socket编程接口的使用，以及如何构建能够处理并发连接的服务器。理解和掌握这些内容对于开发网络应用，尤其是高性能、高并发的服务器...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

枸杞桑葚菊花茶

创作不易，鼓励==>动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值