Linux下C++进行socket连接，多进程+阻塞IO、select进行IO多路复用

已于 2024-04-25 15:17:27 修改
阅读量410 收藏 1
点赞数 1
文章标签： c++
于 2023-07-19 17:20:54 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45089880/article/details/131805864
版权

服务器创建步骤

在B站上看见此视频记录一下，之前并未将socket弄明白，观看之后略懂一二；
【IO多路复用是什么？如何设计一个高性能服务器？】 https://www.bilibili.com/video/BV1WF411R7aK/?share_source=copy_web&vd_source=be53caa3c278a0606cdc59931333e597
【腾讯面试：同步阻塞(BIO)、同步非阻塞(NIO)和Select IO多路复用的原理和不同点】 https://www.bilibili.com/video/BV15X4y1Y7T9/?share_source=copy_web&vd_source=be53caa3c278a0606cdc59931333e597
socket编程的服务器端一般步骤：
在服务器中accept()等待客户端连接为阻塞类型，read()也为阻塞接收；

socket()=>bind()=>listen()=>accept()=>read()=>close(accept)=>close(listen)
1、创建一个socket，用函数socket()； 　　
可选 2、设置socket属性，用函数setsockopt(); *
3、绑定IP地址、端口等信息到socket上，用函数bind(); 　
4、开启监听连接，用函数listen()； 　　
5、接收客户端上来的连接，用函数accept()；
6、收发数据，用函数send()和recv()，或者read()和write(); 　　
7、关闭客户端连接； 　　
8、关闭监听；

socket编程的客户端一般步骤是：

socket()=>connect()=>write()=>close()
1、创建一个socket，用函数socket()； 　　
2、设置socket属性，用函数setsockopt();* 　
3、绑定IP地址、端口等信息到socket上，用函数bind();*
4、设置要连接的对方的IP地址和端口等属性； 　　
5、连接服务器，用函数connect()；
6、收发数据，用函数send()和recv()，或者read()和write(); 　　
7、关闭网络连接；

Socket建议接收发送搭配

接受：
	nbytes = recv(sockfd, buff, buff_size,MSG_WAITALL);
发送：
	nbytes = send(scokfd, buff, buff_size,MSG_WAITALL);

read 原则：数据在不超过指定的长度的时候有多少读多少，没有数据则会一直等待。所以读取数据都需要采用循环读的方式读取数据，因为一次read 完毕不能保证读到我们需要长度的数据，read 完一次需要判断读到的数据长度再决定是否还需要再次读取。

recv 原则：正常情况下recv 等待直到读取到buff_size 长度的数据，但是recv中有个WAITALL ，表示尽量读全，在有中断的情况下recv 还是可能会被打断，造成没有读完指定的buff_size的长度。所以即使是采用recv + WAITALL 参数还是要考虑是否需要循环读取的问题，在实验中对于多数情况下recv (使用了MSG_WAITALL)还是可以读完buff_size。

Read和Recv区别

  1. 接口不同
    • read() 是标准IO函数,来自unistd.h,可以用于文件和socket。
    • recv() 是socket特有的系统调用,来自sys/socket.h
  2. 读取字节数
    • read() 每次都会尝试读取请求的全部字节数。（超出(240*384)时数据读不完）
    • recv() 可能只读取部分数据,需要检查返回值。
  3. 作用对象
    • read() 用于所有文件描述符,包括socket。
    • recv() 只能用于socket描述符。
  4. 标志差异
    • recv() 支持MSG_PEEK等额外标志。
  5. 总结
    • 用于socket时,recv()更为合适,可以处理消息边界,支持标志。
    • 但read()更通用,可以用于文件和socket。

Recv函数

recv先检查套接字的接收缓冲区，如果该接收缓冲区中没有数据或者协议正在接收数据，那么recv就一直等待，直到协议把数据接收完毕。可以设置为非阻塞；

  • 功能：用于从文件描述符对应的文件读取数据

  • 函数体：**int** **recv**(**int** sockfd, **char** ***** buf, **int** len, **int** flags);

    1. sockfd 是文件描述符。
    2. buf 是接收数据的缓冲区地址。
    3. len 表示期望读取的字节数。
    4. flags 指定调用方式，通常为0，或MSG_WAITALL
    flags说明
    MSG_DONTROUTE绕过路由表查找
    MSG_DONTWAIT仅本操作非阻塞
    MSG_OOB发送或接收带外数据
    MSG_PEEK窥看外来消息
    MSG_WAITALL等待所有数据

  • 返回值：

    1. <0 错误
    2. =0 连接关闭
    3. >0 接收到的数据长度大小

阻塞IO 服务器

一个简单的 server端，仅能保持单个客户端连接并信息打印；

服务器代码server.cpp

#include<iostream>
#include<sys/socket.h>
#include<netinet/in.h>
//#include<arpa/inet.h>
//#include<unistd.h>

using namespace std;

int main()
{
	 // 创建socket
    int isockt_fd = socket(AF_INET, SOCK_STREAM, 0);
    if(isockt_fd < 0)
    {
        cout<< "socket create err ...";
	return 0;
    }
	// 设置端口等信息
    struct sockaddr_in addr;
    addr.sin_family = AF_INET;
    addr.sin_port = htons(8888);	// 端口号
    addr.sin_addr.s_addr = htons(INADDR_ANY);
	// 绑定ip地址
    int res = bind(isockt_fd, (struct sockaddr*)& addr, sizeof(addr));
    if(res < 0)
    {
	cout<< "bind err res = "<< res <<endl;
	return 0;
    }
	cout<< "创建成功"<<endl;
	// 监听客户端连接
    listen(isockt_fd, 30);
    
    struct sockaddr_in client;
    socklen_t len = sizeof(client);
    // 阻塞等待客户端连接
    int fd = accept(isockt_fd, (struct sockaddr*)& client, &len);
    if(fd < 0)
    {
    	cout<< "accept err res = " << fd <<endl;
	return 0;
    }
cout<<"链接成功"<<endl;
    char buffer[1024];
	// 阻塞方式接收
    read(fd, buffer, sizeof(buffer));

    cout<<buffer<<endl;
	close(fd);
    close(isockt_fd);
}

客户端代码client.cpp

#include<iostream>
#include<arpa/inet.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<string>

using namespace std;

int main()
{

    int isock_fd = socket(AF_INET, SOCK_STREAM, 0);
    if(isock_fd < 0)
    {
      	cout<< "sockt err ..."<<endl;
	return 0;
    }
    struct sockaddr_in addr;
    addr.sin_family = AF_INET;
    addr.sin_port = htons(8888);
    addr.sin_addr.s_addr = inet_addr("10.10.77.47");
    
    int res = connect(isock_fd, (struct sockaddr*)& addr, sizeof(addr));
    if(res < 0)
    {
	cout<< "connect err ..."<<endl;
	return 0;
    }
    cout<< "链接成功"<<endl;
    string data;
    cout<< "in:";
    cin >> data;
    write(isock_fd, data.c_str(), data.size());
    close(isock_fd);
   	return 0;
}

server编译：g++ server.cpp -o server
client编译：g++ client.cpp -o client

上述方式由于accept()和read()阻塞只能进行单个连接接收，

多进程方式+阻塞IO 服务器

那如何使多个客户端对服务器进行连接呢，那我们就需要使用线程对accept()函数进行多次调用链接，同时将read()也进行循环调用，循环接收进行业务处理

服务器代码server.cpp

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

using namespace std;

int main()
{
    int isockt_fd = socket(AF_INET, SOCK_STREAM, 0);
    if (isockt_fd < 0)
    {
        cout << "socket create err ...";
        return 0;
    }

    struct sockaddr_in addr;
    addr.sin_family = AF_INET;
    addr.sin_port = htons(8888);    // 端口号
    addr.sin_addr.s_addr = htons(INADDR_ANY);

    int res = bind(isockt_fd, (struct sockaddr *)&addr, sizeof(addr));
    if (res < 0)
    {
        cout << "bind err res = " << res << endl;
        return 0;
    }
    cout << "创建成功" << endl;

    // 监听连接请求
    listen(isockt_fd, 30);
    cout << "监听连接请求" << endl;

    // 循环等待新连接accept
    while (1)
    {
        struct sockaddr_in client;
        socklen_t len = sizeof(client);
        // accept 阻塞等待客户端 连接
        int fd = accept(isockt_fd, (struct sockaddr *)&client, &len);
        // 使用detach()方式将线程立即执行
        std::thread([&]()
                    {
            // 需要获取fd的值，不能直接使用fd，（由于Lambda表达式使用&接收后线程都会使用相同的fd描述符）
            int fd_thread = fd; 
            if (fd_thread < 0)
            {
                cout << "accept err res = " << fd_thread << endl;
                return 0;
            }
            cout << "链接成功" << endl;
            while(1)
            {
                char buffer[1024];
                // read阻塞方式接收
                int read_len = read(fd_thread, buffer, 1024);
                if (read_len == 0) // 断开连接
                {
                    cout<<"断开连接"<<endl;
                    close(fd_thread);
                }
                else // 返回字节数 -- 业务逻辑处理
                {
                    cout << buffer << endl;
                    memset(buffer, '\0', sizeof(buffer)); // 清空数组
                }
            }
            
             }).detach();
    }

    close(isockt_fd);
}


编译：g++ server.cpp -o server -lpthread

在这里插入图片描述

IO多路复用select 服务器

select函数用于在非阻塞中，当一个套接字或一组套接字有信号时通知你，系统提供select函数来实现多路复用输入/输出模型

#include <sys/time.h> 
#include <unistd.h>   

int select(int maxfd,fd_set *rdset,fd_set *wrset,fd_set *exset,struct timeval *timeout);

1、maxfd：是需要监视的最大的文件描述符值+1

2、rdset：读文件描述符监听集合，传入、传出参数

3、wrset：写文件描述符监听集合，传入、传出参数

4、exset：异常文件描述符监听集合，传入、传出参数

5、timeout：指向timeval结构体的指针，通过传入的这个timeout参数来决定select()函数的三种执行方式

  1.传入的timeout为NULL，则表示将select()函数置为阻塞状态，直到我们所监视的文件描述符集合中某个文件描述符发生变化是，才会返回结果。

  2.传入的timeout为0秒0毫秒，则表示将select()函数置为非阻塞状态，不管文件描述符是否发生变化均立刻返回继续执行。

  3.传入的timeout为一个大于0的值，则表示这个值为select()函数的超时时间，在timeout时间内一直阻塞，超过时间即返回结果 。

fd_set类型四个宏操作：（fd为文件描述符）

1、void FD_ZERO(fd_set *fdset);将指定的文件描述符集清空，在对文件描述符集合进行设置前，必须对其进行初始化，如果不清空，由于在系统分配内存空间后，通常并不作清空处理，所以结果是不可知的。

2、void FD_SET(int fd, fd_set *fdset); 用于在文件描述符集合中增加一个新的文件描述符。

3、void FD_CLR(int fd, fd_set *fdset);用于在文件描述符集合中删除一个文件描述符。

4、int  FD_ISSET(int fd, fd_set *fdset); 用于测试指定的文件描述符是否在该集合中

可以按照下面的思路来理解这些宏：a[maxfd-1], …, a[1], a[0]

FD_ZERO 用来将这个向量的所有元素都设置成 0；
FD_SET 用来把对应套接字 fd 的元素，a[fd]设置成 1；
FD_CLR 用来把对应套接字 fd 的元素，a[fd]设置成 0；
FD_ISSET 对这个向量进行检测，判断出对应套接字的元素 a[fd]是 0 还是 1。

其中 0 代表不需要处理，1 代表需要处理。

其中还需要使用ioctl()

#include <sys/ioctl.h>
int ioctl(int fd, unsigned long request, ...);

 ioctl 是用来设置硬件控制寄存器，或者读取硬件状态寄存器的数值之类的。
 ioctl(fd, FIONREAD, &b);
 得到缓冲区里有多少字节要被读取，然后将字节数放入b里面。
 FIONREAD用于判断接收缓存中是否存在可读数据，用于accept的socket处于LISTEN状态
 而read,write 是把数据丢入缓冲区，硬件的驱动从缓冲区读取数据一个个发送或者把接收的数据送入缓冲区。

IO多路复用select

server.cpp

#include <iostream>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <stdio.h>
#include <string.h>
#include <thread>
#include <sys/select.h>
#include <sys/ioctl.h>

using namespace std;

int main()
{
    int isocket_fd = socket(AF_INET, SOCK_STREAM, 0);
    if (isocket_fd < 0)
    {
        cout << "socket create err ...";
        return 0;
    }

    struct sockaddr_in addr;
    addr.sin_family = AF_INET;
    addr.sin_port = htons(8888); // 端口号
    addr.sin_addr.s_addr = htons(INADDR_ANY);

    int res = bind(isocket_fd, (struct sockaddr *)&addr, sizeof(addr));
    if (res < 0)
    {
        cout << "bind err res = " << res << endl;
        return 0;
    }
    cout << "创建成功" << endl;

    // 监听连接请求
    listen(isocket_fd, 30);
    cout << "监听连接请求" << endl;

    fd_set read_fds, test_fds;

    FD_ZERO(&read_fds);            // 清空数组
    FD_SET(isocket_fd, &read_fds); // 将socket添加到集合中

    // 循环等待新连接accept
    while (1)
    {
        test_fds = read_fds; // 将需要监视的描述符集copy到select查询队列中，select会对其修改，所以一定要分开使用变量
        // FD_SETSIZE：系统默认的最大文件描述符,进行阻塞当accept()有连接时，进行向下触发
        select(FD_SETSIZE, &test_fds, NULL, NULL, NULL);

        for (int fd = 0; fd < FD_SETSIZE; fd++)
        { // i表示文件描述符
            if (FD_ISSET(fd, &test_fds))
            {
                // 判断是否为socket监听触发
                if (fd == isocket_fd)
                {
                    // 触发accept客户端连接
                    struct sockaddr_in client;
                    socklen_t len = sizeof(client);
                    // accept 阻塞等待客户端 连接
                    int client_fd = accept(isocket_fd, (struct sockaddr *)&client, &len);
                    if (client_fd < 0)
                    {
                        cout << "accept err res = " << client_fd << endl;
                        return 0;
                    }
                    FD_SET(client_fd, &read_fds); // 将客户端fd描述符加入到read_fds集合中
                    cout << "链接成功" << endl;
                }
                else // 客户端有数据请求触发
                {
                    /*
                    得到缓冲区里有多少字节要被读取，然后将字节数放入b里面。
                    ioctl(fd, FIONREAD, &b);
                    */
                    int read_len;
                    ioctl(fd, FIONREAD, &read_len); // fd为select中客户端fd描述符，

                    if (read_len == 0) // 断开连接
                    {
                        cout << "断开连接" << endl;
                        close(fd);
                        FD_CLR(fd, &read_fds);
                    }
                    else if (read_len == -1) // 非阻塞，无数据可读
                    {
                        continue;
                    }
                    else // 返回字节数 -- 业务逻辑处理
                    {
                        char buffer[1024];
                        int read_len = read(fd, buffer, 1024);
                        cout << buffer << endl;
                        memset(buffer, '\0', sizeof(buffer)); // 清空数组
                    }
                }
            }
        }

    }

    close(isocket_fd);
}
D54
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
io多路复用服务器-聊天室.zip
08-29
在Python中，常用的IO多路复用库有`select`、`poll`、`epoll`（适用于Linux）、以及` selectors`模块，这些库允许服务器同时处理多个连接，而无需等待任何一个阻塞的I/O操作完成。在这个项目中，服务器可能使用了`...
tcp socket实现单进程单线程 高并发服务端（c++源码）
11-22
在压缩包文件"TcpServer多种实现"中，可能包含了不同策略的实现，如使用select、poll或epoll的例子，以及可能的优化，如复用已完成IO操作的Socket描述符（`fcntl()`的F_SETFL和O_NONBLOCK标志，或者`epoll_ctl()`的...
二、Linux C/C++ 网络IO多路复用(select/poll/epoll)
weixin_39858918的博客
01-28 1130
LinuxC/C++网络IO多路复用(select/poll/epoll)
Socket编程权威指南(五)高性能 Socket 编程实战
w风雨无阻w的专栏
06-10 1209
需要说明的是，上面的代码只是一个基本框架，你可以根据实际需求进一步扩展和完善，比如添加连接管理、数据缓冲区、日志记录等功能模块。通过不断地探索和实践，相信你一定能掌握高性能网络编程的精髓，构建出卓越的网络应用!
C++ select模型详解（多路复用IO）
田螺姑娘的博客
11-25 2619
C++ select模型详解（多路复用IO） TIPS：以下内容纯属博主自主查阅资料并结合个人理解得出，各位读者仅做参考即可。 关于其它的IO模型可参考链接（阻塞I/O、非阻塞I/O、多路复用I/O、信号I/O、异步I/O）： 引言   在什么情况下需要使用select模型呢？阻塞I/O问题我们可以使用多线程处理或者将阻塞I/O改为非阻塞I/O，系统调用之后就返回结果，可是完成I/O（即获取数据），我们不得不使用polling（轮询），可每次轮询都是一次系统调用，这将导致一些情况下非阻塞I/O甚至不
C++中的IO多路复用（select、poll、epoll）总结
板栗的学习日常
02-16 1864
I/O多路复用（IO multiplexing）是一种并发处理多个I/O操作的机制。它允许一个进程或线程同时监听多个文件描述符（如套接字、管道、标准输入等）的I/O事件，并在有事件发生时进行处理。传统的I/O模型中，通常使用阻塞I/O和非阻塞I/O来处理单个I/O操作。如果需要同时处理多个I/O操作，那么需要使用多个线程或多个进程来管理和执行这些I/O操作。这种方式会导致系统资源的浪费，且编程复杂度较高。而I/O多路复用通过提供一个统一的接口，如select、poll、epoll。
I/O多路复用【Linux/网络】（C++实现select、poll和epoll服务器）
Man9o
10-08 654
I/O 多路复用（也叫多路转接）是一种解决方案，它可以让一个进程或线程同时监控多个文件描述符（通常是网络套接字），并在其中一个或多个文件描述符准备好进行 I/O 操作时（至少一个），通知应用程序进行相应的读写操作。这样，应用程序可以在等待数据的过程中执行其他任务，而不会被阻塞，从而提高了程序的性能和响应速度。I/O 多路复用的实现方式有多种，比如 select，poll，epoll 等，它们各有优缺点，具体的选择要根据应用场景和需求来决定。
SOCKET【2】-IO多路复用select
m0_46535940的博客
05-28 591
文章目录前言一、socket阻塞模式二、socket非阻塞模式三、select 相关API介绍与使用3.1 seletct API3.2 seletct 使用范例四、深入理解select 模型五、用select处理外带数据六、用select来解决socket中的多客户端问题总结 前言 提示：展示select如何使用 一、socket阻塞模式 所谓阻塞模式block是指线程或者进程执行这些函数时必须等待直到某一事件的发生才能返回，如果事件不发生，进程或者线程被阻塞，函数不能立即返回。 二、socket非阻
IO多路复用之select
qq_52836452的博客
10-15 1930
本文讲解了IO多路复用，详细的讲解了select函数，并通过select实现了select服务器程序实例让大家深入了解了select多路复用，希望这篇博客可以让大家有所收获。
【C++基本语法】Linux IO多路复用select, poll, epoll特性对比
weixin_40192753的博客
04-25 831
本文介绍IO多路复用的几个特点，重点在特性对比和底层数据结构
【Socket编程】篇六之IO多路复用——select、poll、epoll
热门推荐
mick_seu的博客
06-12 1万+
文章参考自：http://blog.csdn.net/tennysonsky/article/details/45745887（秋叶原 — Mike VS 麦克《Linux系统编程——I/O多路复用select、poll、epoll的区别使用》） 在上一篇中，我简单学习了 IO多路复用的基本概念，这里我将初学其三种实现手段：select，poll，epoll。 I/O 多路复用
linux-socket-2.rar_Linux C socket_linux c++ socket_linux socke
09-22
Linux提供了多路复用I/O模型，如select、poll和epoll，它们可以帮助程序同时监控多个Socket，提高并发处理能力。特别是epoll，提供了高效的大规模Socket管理方案。 八、异步IO和非阻塞IO 异步IO模型如 aio 和 event...
Linux多线程编程手册,linux多线程编程手册pdf,C,C++
09-11
- **非阻塞IO与I/O复用**：利用`fcntl()`设置非阻塞模式，或使用`select()`、`poll()`、`epoll()`等函数进行I/O复用，提高并发性能。 - **异步I/O模型**：如`aio`库，允许线程在I/O操作完成后再被通知，避免阻塞...
IO模型中的阻塞模型和非阻塞模型
01-20
- **Epoll模型**：是Linux内核提供的高级多路复用技术，相比于`select()`和`poll()`，`epoll`具有更高的效率。`epoll`的核心思想是利用内核中的事件表来记录各个套接字的状态变化，只有状态发生变化的套接字才会被...
【C++】C++中的find方法介绍
qq_35902025的博客
07-25 409
find 函数是 std::string 类中非常有用的成员函数之一，它提供了灵活的方式来查找子字符串或字符。使用 npos 可以检查查找操作是否成功。
背单词工具(C++)
zeyeqianli的博客
07-24 3460
【代码】背单词工具(C++)
C：图案打印
2401_85010100的博客
07-23 972
空心正方形，空心三角形，X形，沙漏图案打印
C++| STL之迭代器和vector
最新发布
qq_40306845的博客
07-25 348
C++STL迭代器是介绍和使用，以及vector工具的理解和使用。
c++ io多路复用
09-13
3. epoll函数：epoll是Linux下高性能的IO多路复用机制。它可以监听大量文件描述符并返回就绪的事件，相比select和poll具有更高的性能。通过使用epoll_create创建一个epoll实例，并通过epoll_ctl来添加、修改和删除要...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值