网络编程笔记6

已于 2024-05-23 21:12:31 修改
阅读量57 收藏
点赞数 1
分类专栏： 网络编程笔记 文章标签： 笔记 c++ 服务器 linux
于 2024-05-20 21:04:52 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_80090730/article/details/139060716
版权

这章主要介绍并发服务器的实现方法

在linux系统下创建进程使用fock()函数，通过getpid()函数可以查看当前进程的PID.

父进程就是当前main()函数的进程。下图如果if后面还有代码，各个进程执行了属于自己的if部分的操作后还会执行if后面的代码块，即父子进程都会执行if块后面的代码。

include<iostream>
#include<unistd.h>
 int a=10;
int main(int argc,char* argv[]){
    std::cout<<"hello"<<std::endl;
    std::cout<<"the  pid is: "<<(int)getpid()<<std::endl;
    ++a;
    pid_t s=fork();//进程开始
if((int)s==0){
    std::cout<<" i am cl:"<<(int)getpid()<<std::endl;
    a=a*2;
    std::cout<<a<<std::endl;
}else if((int)s>0){
    a++;
    std::cout<<"the fa pid is: "<<(int)getpid()<<std::endl;
    std::cout<<a<<std::endl;
}

std::cout<<a<<std::endl;//各个进程除了执行括号内的操作  还会执行此代码。
return 0;
    
}

一个进程被创建后执行完相应代码后应改被消除，如果不被消除就会不断占用CPU资源，这样的进程被称之为僵尸进程。

下面将介绍消除僵尸进程的方法：

1.调用wait函数

下面是代码演示：

#include<iostream>
#include<unistd.h>
#include <stdlib.h>
#include<sys/wait.h>
int main(){
    int sat;
    int pid=fork();
    if(pid==0){
        return 3;//向父进程传递子进程return的值 子进程1结束
    }
    else{
        std::cout<<"the chiid1 :"<<pid<<std::endl;
        std::cout<<"the far :"<<(int)getpid()<<std::endl;
        pid=fork();
        if(pid==0){
            exit(7);//子进程2结束
        }
        else{
            std::cout<<"the child2 :"<<pid<<std::endl;
            wait(&sat);
            if(WIFEXITED(sat)){
                std::cout<<"the child11 :"<<WEXITSTATUS(sat)<<std::endl;
            }

            wait(&sat);
            if(WIFEXITED(sat)){
                std::cout<<"the child22 :"<<WEXITSTATUS(sat)<<std::endl;
            }
            sleep(5);
        }

    }

}

注意return 3，向父进程返回子进程的值，不会产生僵尸进程 exit(7)也避免产生僵尸进程。

如上，将子进程返回的消息存入在sat中,因为创建了两个子进程，所以调用两次wait函数。

但要注意：

wait函数可能会陷入阻塞。

方法是调用waitpid函数：

注意是第三个参数是防止阻塞的，即使没有结束的子进程，也会返回0

下面是代码演示：

#include<iostream>
#include<unistd.h>
#include <stdlib.h>
#include<sys/wait.h>
int main(){
    int sat;
    int pid=fork();
    if(pid==0){
        sleep(15);//子进程代码先推迟15秒 这样子进程就不会消亡
        return 24;
    }else{
        while(!waitpid(-1,&sat,WNOHANG)){//由于子进程未消亡 该函数一直返回0 所以一直执行父进程代码
            sleep(3);
            std::cout<<"sleep 3 mins"<<std::endl;
        }
    }
    if(WIFEXITED(sat)){
std::cout<<"chile setid: "<<WEXITSTATUS(sat)<<std::endl;
    }
    return 0;

}

调用sleep和wait函数可以调用子父进程执行的顺序。 这个小技巧要注意。

那么子进程究竟何时才会停止？需要信号量机制，注册信号量机制要特殊的函数，且是由操作系统调用，调用信号量函数会调用自定义函数。下面是函数：

下面介绍alarm函数：

注意上述描述，约定信号后要指定此信号对应的处理函数，若未处理会终止进程（通过signal函数调用的函数）。下面代码演示： 
#include<iostream>
#include<unistd.h>
#include<signal.h>
 
void timeout(int sig){//定义信号处理函数
    if(sig==SIGALRM){
        std::cout<<"Time out"<<std::endl;
    }
    alarm(2);//信号处理函数中调用alarm函数 每隔两秒产生SIGALRM信号 因此就会一直调用
}

void aa(int sid){//定义信号处理函数
    if(sid==SIGINT){
std::cout<<"CTRL+C pressed"<<std::endl;
    }
}

int main(){
    int i;
    signal(SIGALRM,timeout);//注册信号量和信号处理器
    signal(SIGINT,aa);//注册信号量和信号处理器
    alarm(2);//预约两秒后产生信号 产生后将会调用timeout函数
    for(int i=0;i<3;i++){
        puts("wait..");
        sleep(100);
    }
    return 0;
}

注意上述是sleep了三次 当产生信号时会唤醒因为sleep函数而陷入阻塞的进程，当进程被唤醒时不会再进入睡眠状态。所以上述函数是如下运行，当先执行到main()里的alarm(2)时，约定两秒后产生信号，在这两秒内执行for循环内的代码，本应该每次循环拖迟100秒，但是两秒过后产生了信号，执行了timeout函数 被阻塞的进程被唤醒，依次循环三次。

下面将介绍sigcation函数 以此代替signal函数。

代码演示如下：

#include<iostream>
#include<unistd.h>
#include<signal.h>
 
void timeout(int sig){//定义信号处理函数
    if(sig==SIGALRM){
        std::cout<<"Time out"<<std::endl;
    }
    alarm(2);//信号处理函数中调用alarm函数 每隔两秒产生SIGALRM信号 因此就会一直调用
}

void aa(int sid){//定义信号处理函数
    if(sid==SIGINT){
std::cout<<"CTRL+C pressed"<<std::endl;
    }
}

int main(){
    struct sigaction act;//定义结构体变量
    act.sa_handler=timeout;//变量内部声名函数指针
    act.sa_flags=0;//初始化该成员为0
    sigemptyset(&act.sa_mask);//调用函数初始化该成员
    sigaction(SIGALRM,&act,0);//注册信号量信息。
    alarm(2);
    for(int i=0;i<3;i++){
        puts("wait..");
        sleep(100);
    }
    return 0;
}

下面我们将利用引号量消除僵尸进程，代码如下，请不用关注子进程的运行顺序，只关系是否消除关于僵尸进程：

#include<iostream>
#include<unistd.h>
#include<sys/wait.h>
#include<netdb.h>
#include<string.h>
void read(int sig){
    pid_t pid;
    int state;
    pid=waitpid(-1,&state,WNOHANG);//结束进程的消息存入在此变量中
    if(WIFEXITED(state)){
    std::cout<<" reomve the chrl pid:  "<<pid<<std::endl;
    std::cout<<"chrl send :   "<<(WEXITSTATUS(state))<<std::endl;
    }
}
int main(int argc,char* argv[]){
pid_t pid;
int state;
struct sigaction act;
act.sa_flags=0;
act.sa_handler=read;
sigemptyset(&act.sa_mask);
sigaction(SIGCHLD,&act,0);//注册信号量 当有子进程消失时会调用act中的函数指针


pid=fork();//创建子进程

if(pid==0){
    std::cout<<"hello im chrl pid:"<<(int)getpid()<<std::endl;//显示子进程的ID号
    sleep(10);//推迟12秒
    return 12;
}else{
    std::cout<<" hello im father :"<<(int)getpid()<<std::endl;
    std::cout<<" the chrl pid :"<<pid<<std::endl;
    pid=fork();
if(pid==0){
    std::cout<<" im another chr pid :"<<(int)getpid()<<std::endl;
sleep(10);
return 24;
}else{
    std::cout<<"the another chr :"<<pid<<std::endl;
    for(int i=0;i<5;i++){
        puts("wait...");
        sleep(5);
    }
}
}
return 0;
}

下面我们将开始简单的并发服务器：

如上图，每当由客户端请求连接时，父进程都会创建一个子进程进行提供服务。

下面是并发服务器的客户端，如果有五个请求连接 那么可以同时为五个客户端解决数据，再次注意信号量机制是为了防止僵尸进程的产生，先不要在意各个进程的运行顺序。

#include<iostream>
#include<sys/socket.h>
#include<unistd.h>
#include<cstring>
#include<arpa/inet.h>
#include<sys/wait.h>
const int MAX_SIZE=30;
void read(int sig);
int main(int argc,char* argv[]){
    int sock_ser,cil_ser,state,len;
    socklen_t cil_size;
    struct sockaddr_in serv,cil;
    pid_t pid;
    char buf[MAX_SIZE];
    if(argc!=2){
        std::cout<<"error"<<std::endl;
        exit(1);
    }
    sock_ser=socket(PF_INET,SOCK_STREAM,0);
    memset(&serv,0,sizeof(serv));
    serv.sin_family=AF_INET;
    serv.sin_addr.s_addr=htonl(INADDR_ANY);
    serv.sin_port=htons(atoi(argv[1]));
    struct sigaction act;
    act.sa_flags=0;
    sigemptyset(&act.sa_mask);
    act.sa_handler=read;
    state=sigaction(SIGCHLD,&act,0);//信号量设置为 子进程结束时才调用函数 防止僵尸进程产生

    if(bind(sock_ser,(struct sockaddr*)&serv,sizeof(serv))==-1){
        std::cout<<"bind()error"<<std::endl;
    }

    if(listen(sock_ser,5)==-1){
        std::cout<<"listen()error"<<std::endl;
    }


while(1){
    cil_size=sizeof(cil);
    cil_ser=accept(sock_ser,(struct sockaddr*)&cil,&cil_size);
    if(cil_ser==-1){//创造失败跳过
        continue;
    }else{
        puts("new cil connect........");
        pid=fork();
        if(pid==-1){
close(cil_ser);//子进程创建失败 关闭套接字
continue;//继续
        }
        if(pid==0){
            close(sock_ser);
            while((len=read(cil_ser,buf,MAX_SIZE))!=0)
            write(cil_ser,buf,len);//传输信息

            close(cil_ser);  //传输完毕 关闭套接字
            puts("disconncet........");
            return 0;//结束循环
        }else{
            close(cil_ser);
        }
    }
}
close(sock_ser);
return 0;
}

void read(int sig){
    pid_t pid;
    int state;
    pid=waitpid(-1,&state,WNOHANG);
    std::cout<<"remove id:"<<pid<<std::endl;
}//当有一个子进程结束时 会调用移除ID

//先不要关心子进程的运行顺序

上面代码注意：while(1)中，pid=0时关闭了服务器的套接字，这里是因为父进程将创建的服务器套接字的文件描述符传递给了子进程，但子进程只进行数据传输，所以要关闭子进程带有的服务端套接字文件描述符，保留父进程的套接字文件描述符。 还有pid>0部分关闭了连接客户端的套接字文件描述符，这是因为 调用的accept函数创建的套接字文件描述符已经赋值给了子进程，传输数据任务交给子进程，传输完毕后由子进程关闭连接客户端的套接字文件描述符。所以由父进程产生的受理客户端的套接字文件描述符不要忘了同时关闭。

多个文件描述符对应一个套接字，父进程不会赋值套接字给子进程，因为套接字属于操作系统，将文件描述符看作套接字的定位。只有关闭所有的套接字描述符才会使得套接字关闭。

下面将介绍切割I/O，对于一般的回声客户端，其传输数据后需要等待服务器返回的数据，因为代码中一直调用write和read函数且只有一个进程在进程，现在可以创造多个进程分割IO，这样不论客户端是否接受数据都可以接受，如下图：

如上图，父进程只读，子进程只些，确认分工，而不是一个进程做多个事。具体效果对比下图，左边是未使用的，右边是使用I/O切割。

下面是简单的代码实现：

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

const int MAX_SIZE=30;
void read1(int ,char*);
void write1(int,char*);

int main(int argc,char* argv[]){
int sock;
pid_t pid;
char buf[MAX_SIZE];
struct sockaddr_in cil_serx;
if(argc!=3){
    std::cout<<"error()"<<std::endl;
    exit(1);
}
sock=socket(PF_INET,SOCK_STREAM,0);
memset(&cil_serx,0,sizeof(cil_serx));
cil_serx.sin_family=AF_INET;
cil_serx.sin_addr.s_addr=inet_addr(argv[1]);
cil_serx.sin_port=htons(atoi(argv[2]));
if(connect(sock,(struct sockaddr*)&cil_serx,sizeof(cil_serx))==-1){
    std::cout<<"connect()error()"<<std::endl;
}

pid=fork();//创建子进程  注意已经赋值了文件描述符
if(pid==0){
    write1(sock,buf);
}else{
    read1(sock,buf);
}
close(sock);
return 0;
}

void read1(int sock,char* buf){
    while(1){
        int leth=read(sock,buf,MAX_SIZE);//考虑传输数据过大是TCP会分包传送 所以这里都是传输的是短数据
        if(leth==0)
        return;

        buf[leth]=0;
        std::cout<<buf<<std::endl;
        
    }
}

void write1(int sock,char* buf){
    while(1){
        fgets(buf,MAX_SIZE,stdin);
        if(!strcmp(buf,"Q\n")||!strcmp(buf,"q\n")){
            shutdown(sock,SHUT_WR);//由于只有关闭所有文件描述符才能关闭套接字，这里采用半关闭的原因是 客户端不能向服务端传输数据，但还可以接受服务端的数据，因为是切割I/O，不管服务端接受是否都可以发送，
            break;//如果全部关闭可能会导致信息接受不全。
        }
        write(sock,buf,strlen(buf));
    }
}

注意套接字的半关闭，如上半关闭写的操作后，套接字最后在接受服务端传来的数据，接受了数据之后，会完全关闭客户端套接字。

2301_80090730
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
网络安全-自学笔记
关注网络安全、云原生安全
12-01 17万+
目录 WEB（应用）安全 前端安全 xss攻击 后端安全 文件上传漏洞 WebShell 解析安全 数据安全 sql注入 通信安全 WEB（应用）安全 前端安全 xss攻击 后端安全 文件上传漏洞 WebShell 解析安全 数据安全 sql注入 网络安全-sqlmap学习笔记 通信安全 网络-http协议学习笔记（消息结构、请求方法、状态码等） ...
C++ Socket网络编程笔记
dream_to_dream的博客
09-06 459
C++网络编程学习笔记
SRv6网络编程阅读笔记
csdn_ggboy的博客
11-25 4434
SRv6技术
Linux网络编程笔记
weixin_48591705的博客
07-06 501
笔记
Linux网络编程复习笔记
小谢的博客
12-01 5852
理论知识点 TCP协议的三次握手的触发API connect : 第一次握手信息 第二次，第三次都是被动处理，无需调用接口 accept不参与三次握手，取出三次握手成功的描述符 socket描述符的合理大小 属于linux系统描述符fd的一部分: fd∈[0,1,2……]fd\in[0,1,2……]fd∈[0,1,2……] 总之fd>=0fd>=0fd>=0 把socket状态从主动发送状态转变为被动监听状态 listen + TCP的描述符 send(sockfd, buf, 5
一部分网络编程笔记总结
08-09
这些笔记主要涵盖了Java网络编程的基础概念、核心技术以及一些实践应用。下面将详细展开讲解相关知识点。 1. **网络基础知识**：网络编程首先需要理解TCP/IP协议族，包括IP地址、端口号、传输层（TCP/UDP）以及应用...
linux系统编程及网络编程笔记
04-12
总的来说，"Linux系统编程及网络编程笔记"会详细解析上述各个方面，包括理论知识、实际示例和最佳实践，旨在帮助学习者深入理解Linux环境下的系统编程和网络编程，为开发高效、安全的系统级应用程序和网络服务打下...
linux系统编程和网络编程笔记
07-23
linux系统编程和网络编程笔记
网络编程笔记
12-16
网络对计算机来说有多么重要就不再多说了，想学好网络编程也是不容易的，其中好的笔记就是不错的选择，能是你的学习效率达到事半功倍的效果，不要犹豫了，学好网络编程将是你在程序员路上的一大优势，带来意想不到的...
C语言的网络编程笔记
07-09
本篇文章将详细解析C语言在进行网络编程时的关键知识点，结合"网络编程笔记-第六天"这个文件名，我们可以推测这是一份逐步深入的学习材料。 1. **套接字（Sockets）编程**： C语言中的网络编程主要通过套接字接口...
维度不固定的多维数组形参笔记
H2z1220的博客
09-05 188
假如我有多个元素个数都不一致的多维数组都需要调用这个函数进行处理，这个形参问题就凸显出来了，总不能创建N个不同的函数来进行处理吧？这样也太繁琐了，而且也适用度不高。这个函数可以传入多维数组，但元素个数必须是固定的，假如传入一个str[][20]，元素个数不一样的数组，那么这个函数就不适用了，且会报错。所有数据在存储空间里面都是有地址的，那么就可利用指针寻址来获取到相应的数据。在查找了一些资料后受到了一点启发。而这里也可利用指针来指向多维数组。
【机器人工具箱Robotics Toolbox开发笔记（十）】机器人微分运动学
最新发布
m0_72676510的博客
09-07 178
机器人工具箱中，可用函数SerialLink.jacob0（）求出对应某个位姿下绝对坐标系中的雅可比矩阵，用SerialLink.jacobn（）求出对应某个位姿下工具坐标系中的雅可比矩阵。
从零开始：我的JaveWeb学习笔记之网页设计初探：探索 HTML 、CSS的奇妙世界（JavaWeb、HTML、CSS）
Hanbuhuic的博客
09-04 1539
HTML（HyperText Markup Language）是一种用于创建网页的标准标记语言。它定义了网页的结构和内容，但不包括样式和行为。HTML 由一系列的元素组成，这些元素可以被浏览器识别并渲染成可视化的网页。CSS（层叠样式表，Cascading Style Sheets）是一种用于描述HTML或XML文档的样式表语言。它能够控制网页的布局、颜色、字体以及其他视觉和版式特性。CSS 允许开发者将页面的内容（HTML）与页面的表现（CSS）分离，这样可以更灵活地进行设计和维护。
C++学习笔记（10）
qq_60098634的博客
09-07 447
unordered_multimap 和 unordered_map 的区别在：unordered_multimap 允许关键字重复，而。unordered_multiset 和 unordered_set 的区别在：unordered_multiset 允许关键字重复，而。
7月刷题笔记
sad_liu的博客
09-04 1373
刷题笔记—7月 1512.好数对的数目(哈希) class Solution { public: int numIdenticalPairs(vector<int>& nums) { int cnt = 0; unordered_map<int, int> hash;//nums[i]---个数 for(int i = 0; i < nums.size(); i++) { cnt += ha
【机器人工具箱Robotics Toolbox开发笔记（一）】Matlab机器人工具箱简介
m0_72676510的博客
09-04 172
MATLAB的Robotics Toolbox（简称RTB）是一款在MATLAB环境下进行机器人建模、仿真和控制的工具箱。它由Peter Corke教授开发，已成为机器人领域中最受广泛使用的MATLAB工具箱之一。
C语言学习笔记 Day16（C10文件管理--下）
给bug两拳的博客
09-04 1271
1、查询文件状态；2、文件的随机读写：fseek()、rewind()；3、文件的删除和重命名：remove()、rename()；4、文件缓冲区：基础概念、更新缓冲区
【扇贝编程】使用Selenium模拟浏览器获取动态内容笔记
m0_73676887的博客
09-03 1670
文章目录selenium安装 selenium下载浏览器驱动获取数据处理数据查找一个元素查找所有符合条件的元素控制浏览器 selenium selenium是爬虫的好帮手， 可以控制你的浏览器，模仿人浏览网页，从而获取数据，自动操作等。 我们只要让 selenium 自动控制浏览器，实现爬取数据、自动抢票…… selenium要打开浏览器并控制它，占用的资源会更多，爬取数据的效率也会有所降低。 安装 selenium pip install selenium 下载浏览器驱动 根据你使用的浏览器（如 Chr
NLP面试题（9月4日笔记）
ldk的博客
09-04 842
GRU中的另一个门被称为重置门，控制要遗忘多少过去的信息；GRU可看作是LSTM的一个变体，与LSTM相比，GRU只有两个门，将LSTM中的输入门和遗忘门合二为一，称为更新门，控制前边记忆信息能够继续保留到当前时刻的数据量，或者说决定有多少前一个时间步的信息和当前时间步的信息要被继续传递到未来；自然语言处理领域内所需要处理的信息通常是文本、语音等序列化的数据，对应数据通常会有较强的上下文依赖关系，因此在对对应的数据进行处理时，不仅需要了解当前数据的相关信息，同时还需要能够对上下文之间的数据能够有所了解。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值