深入浅出--UNIX多进程编程之fork()函数

UNIX 环境编程 之 fork 函数详解 一 概述 一个进程,包括代码、数据和分配给进程的资源。fork()函数通过系统调用创建一个与原来进程几乎完全相同的进程,也就是两个进程可以做完全相同的事,但如果初始参数或者传入的变量不同,两个进程也可以做不同的事。 二 fork 函数 fork调用的一个奇妙之处就是它仅仅被调用一次,却能够返回两次,它可能有三种不同的返回值: 1)在父进程中,fork返回新创建子进程的进程ID; 2)在子进程中,f... 阅读详情

http://blog.youkuaiyun.com/wallwind/article/details/6996004

0前言

上周都在看都在学习unix环境高级编程的第八章——进程控制。也就是这一章中,让我理解了unix中一些进程的原理。下面我就主要按照进程中最重要的三个函数来进行讲解。让大家通过阅读这一篇文章彻底明白进程这点事。希望对大家有所帮助。

1进程环境

         在学习进程之前,一定要了解一下unix的进程环境。系统如何对进程终止,和一个程序启动终止,程序运行的原理等,这些都有助于你理解进程的运行原理。这些内容都在我的上一篇文章中,请关注:http://blog.youkuaiyun.com/wallwind/article/details/6968323。文章中讲的较为详细。

2进程概念:

一个进程,主要包含三个元素:

a)        一个可以执行的程序;

b)        和该进程相关联的全部数据(包括变量,内存空间,缓冲区等等);

c)        程序的执行上下文(execution context)。

不妨简单理解为,一个进程表示的,就是一个可执行程序的一次执行过程中的一个状态。操作系统对进程的管理,典型的情况,是通过进程表完成的。进程表中的每一个表项,记录的是当前操作系统中一个进程的情况。对于单 CPU的情况而言,每一特定时刻只有一个进程占用 CPU,但是系统中可能同时存在多个活动的(等待执行或继续执行的)进程。

3 fork()函数

         fork()函数是进程的核心函数。当调用fork的时候,系统将创建一个新的进程,成为子进程(child process)。Fork函数定义形式如下:

  1. #include<unistd.h>  
  2.   
  3. Pid_t fork(void);//返回值:子进程返回0,父进程中返回子进程ID,出错则返回-1  


从返回值我们可以看到,Fork函数调用了一次,但是返回两次。其区别在于在子进程中返回值是0,而父进程的返回值则是新子进程的进程ID.

         上边的概念可能对初学者比较模糊,那么我们怎么理解fork呢?

         当你看到fork的时候,你可以把fork理解成“分叉”,在分叉的同时,生成的一个子进程复制了父进程的基本是所有的东西,包括代码、数据和分配给进程的资源。也就是子进程几乎是和父进程是一模一样的。但是子进程可能会根据不同情况调用其他函数。比如exec函数。

         下面我们用一个经典及比较典型简单的例子来看看。

    

  1.     #include"apue.h"  
  2.   
  3.   
  4. int glob=6;  
  5.   
  6. char buf[]="a write to stdout\n";  
  7.   
  8.    
  9.   
  10. int main(void)  
  11.   
  12. {  
  13.   
  14.        int var=88;  
  15.   
  16.        pid_t pid;  
  17.   
  18.    
  19.   
  20.        if(write(STDOUT_FILENO,buf,sizeof(buf)-1)!=sizeof(buf)-1)  
  21.   
  22.                 printf("writeerror");  
  23.   
  24.    
  25.   
  26.        printf("before fork with  换行符\n");  
  27.   
  28.        printf("before fork without换行符");     
  29.   
  30.        //printf("\n");  
  31.   
  32.    
  33.   
  34.        if((pid=fork())<0){  
  35.   
  36.                 printf("fork error");  
  37.   
  38.    
  39.   
  40.        }else if(pid==0){  
  41.   
  42.                 printf("I am is  child process,pid=%d\n",getpid());  
  43.   
  44.                 printf("my parentprocess's pid=%d\n",getppid());  
  45.   
  46.                 glob++;  
  47.   
  48.                 var++;  
  49.   
  50.        }else{  
  51.   
  52.                 printf("this is parentprocess,pid=%d\n",getpid());  
  53.   
  54.                 //var++;  
  55.   
  56.        }  
  57.   
  58.    
  59.   
  60.        printf("pid=%d,glob=%d,var=%d\n",getpid(),glob,var);  
  61.   
  62.        exit(0);  
  63.   
  64. }  


输出结果:                             

希望新手能够将以上代码自己敲一遍,然后自己运行一遍。

从上边的结果我们一步步分析。首先我们看到两行文字是只输出一遍的。

既”a write to stdout”

         “Befork forkwhit h换行符”。

也就是只有一个进程执行这两个输出语句。我们先暂且不分析不带换行符的。

当程序调用fork的时候,这个时候程序就出现了一个进程,也就是两个进程在执行。

请看下边的简易图形

在上边我们已经讲过fork函数会因为不同调用返回不同的函数值:

1)在父进程中,fork返回新创建子进程的进程ID;

2)在子进程中,fork返回0;

3)如果出现错误,fork返回一个负值;

现在我们看程序里的几个函数。Write函数是将buf内容写到标准流中。此处只作为输出用。

我们关心的是getpid()函数和getppid()函数。

getpid()函数是用来输出当前成进程的ID,getppid()则得到当前进程的父进程的ID,从输出结果比对可以看到,子进程得到的父ID和父进程得到自己的ID是相同的。

再来看一下全局变量glob,glob是函数外的变量。子进程将glob++处理,这个时候输出的是7,父进程没有进行处理直接输出6。我们可以知道,这两个glob变量显示是两份的。不相干的。

局部变量var也是同样的结果。。。。

现在我们来解释一下为什么

  1. printf("before fork with  换行符\n");  
  2.   
  3. printf("before fork without换行符");     


上一句只输出了一次,而下边这句话就输出了两次。

我们可以发现printf("before fork with  换行符\n");这句带有\n既换行符的意思。而

  1. printf("before fork without换行符");     


是没有带的。

这个我们要知道printf函数是有缓冲机制的,类似于我们使用的write函数,但我们将想要的东西输出的时候,系统仅仅是把内容放到stdout标准输出的缓冲队列的。当遇到“\n”的时候,系统就把缓冲里的东西给清掉,输出到屏幕上。

        

  1. printf("beforefork with  换行符\n");  


执行后,缓冲里没有了数据,自然子进程再次执行的时候没有内容可输出了。但是printf("before fork without换行符");的时候,子进程也会把stdout的内容再次输出来。也就是导致了内容出处了两边。如果换一下书序的,结果是不一样的哦。

3 fork难度进阶

csdn看到一篇比较好的讲解fork的文章。较为深入的讲解。下面我就经过自己的调试和理解将呈现给大家。首先看一段代码:

  1. #include "apue.h"  
  2.   
  3.    
  4.   
  5. int main(void)  
  6.   
  7. {  
  8.   
  9.        int i=0;  
  10.   
  11.        pid_t pid;  
  12.   
  13.    
  14.   
  15.        for(i=0;i<2;i++)  
  16.   
  17.        {  
  18.   
  19.                 if((pid=fork())<0){  
  20.   
  21.                         printf("forkerror\n");  
  22.   
  23.                 }else if(pid==0){  
  24.   
  25.                        printf("%d,childself's pid=%d,parent's pid=%d,returnid=%d\n",i,getpid(),getppid(),pid);  
  26.   
  27.                }else{  
  28.   
  29.                        printf("%d,parentself's pid=%d,parent's father's pid=%d,returnid=%d\n",i,getpid(),getppid(),pid);  
  30.   
  31.                         sleep(2);//inorder tochild output first  
  32.   
  33.                 }  
  34.   
  35.        }  
  36.   
  37.        exit(0);  
  38.   
  39. }  


输出的结果为:

好好的分析一下我们的结果。0开始的输出为2行,1开头的输出4行。

然后我们开始观察PID的结果。从pid的结果我们找到一个关系

既9278-》30361-》30362-》30363

9278-》30361-》30364

要知道,fork函数子进程调用的时候返回0,而父进程调用的时候则返回子进程的ID。

程序运行第一步:

  1. if((pid=fork())<0){  
  2.   
  3.                         printf("forkerror\n");  
  4.   
  5.                 }else if(pid==0){  
  6.   
  7.                        printf("%d,childself's pid=%d,parent's pid=%d,returnid=%d\n",i,getpid(),getppid(),pid);  
  8.   
  9.                 }else{  
  10.   
  11.                        printf("%d,parentself's pid=%d,parent's father's pid=%d,returnid=%d\n",i,getpid(),getppid(),pid);  
  12.   
  13.                         sleep(2);//inorder tochild output first  
  14.   
  15.                 }  


输出的结果为:

这是第一次循环输出输出的。

Childpid和return 均为父ID为30361生成的30361。

此时已经有了两个进程了。

进程ID分别为30362和30361。

第二次循环输出。

我们知道了此时两个进程30362和30361。这两个进程分别执行自己的代码。

ü  这个时候pid为30362的进程进行一次:

循环,得到结果为:

    
生成了一个子进程30363

ü  30361进程再次执行自己的代码,也就是上述循环的部分。

生成了一个子进程30364.

从程序和输出结果可以看到,其实我们的程序得到了6份的拷贝。

通过这个例子,fork了三次,产生了三个子进程,输出了6次,你可以深刻的理解了fork工作原理了。

再来一个例子:

这个是典型的循环例子:

  1. #include <unistd.h>  
  2.   
  3. #include<stdio.h>  
  4.   
  5.    
  6.   
  7. int main(void)  
  8.   
  9. {  
  10.   
  11.        pid_t pid;  
  12.   
  13.        int i=0;  
  14.   
  15.        int c_cout=0;  
  16.   
  17.        int p_cout=0;  
  18.   
  19.        for(i=0;i<5;i++)  
  20.   
  21.        {  
  22.   
  23.                 if((pid=fork())<0){  
  24.   
  25.                         printf("forkerror\n");  
  26.   
  27.                 }else if(pid==0){  
  28.   
  29.                         c_cout++;  
  30.   
  31.                }else{  
  32.   
  33.                         p_cout++;  
  34.   
  35.                 }  
  36.   
  37.    
  38.   
  39.        }  
  40.   
  41.        printf("c_cout=%d,p_cout=%d,pid=%d\n",c_cout,p_cout,getpid());  
  42.   
  43.    
  44.   
  45. }  


输出结果为:c_cout=5,p_cout=0,pid=1559

c_cout=4,p_cout=1,pid=1558

c_cout=4,p_cout=1,pid=1560

c_cout=3,p_cout=2,pid=1557

c_cout=4,p_cout=1,pid=1562

c_cout=3,p_cout=2,pid=1561

c_cout=4,p_cout=1,pid=1566

c_cout=3,p_cout=2,pid=1565

c_cout=3,p_cout=2,pid=1569

c_cout=2,p_cout=3,pid=1568

c_cout=4,p_cout=1,pid=1574

c_cout=3,p_cout=2,pid=1573

c_cout=3,p_cout=2,pid=1577

c_cout=2,p_cout=3,pid=1576

c_cout=3,p_cout=2,pid=1581

c_cout=2,p_cout=3,pid=1580

c_cout=2,p_cout=3,pid=1584

c_cout=1,p_cout=4,pid=1583

c_cout=3,p_cout=2,pid=1563

c_cout=2,p_cout=3,pid=1556

c_cout=2,p_cout=3,pid=1564

c_cout=2,p_cout=3,pid=1570

c_cout=1,p_cout=4,pid=1555

c_cout=3,p_cout=2,pid=1575

c_cout=2,p_cout=3,pid=1572

c_cout=2,p_cout=3,pid=1578

c_cout=1,p_cout=4,pid=1571

c_cout=2,p_cout=3,pid=1582

c_cout=1,p_cout=4,pid=1579

c_cout=1,p_cout=4,pid=1585

c_cout=0,p_cout=5,pid=1554

通过推理:引用网络文章可得到:

设f(n)表示程序中循环会执行n次时整个程序会产生的进程数,很容易得到递推公式:

f(n)=1+f(n-1)+f(n-2)+f(n-3)+…+f(0)

比如for i=0;i<N;I++< p>

因为i=0时fork()的子进程下次会继续循环n-1次,i=1时 fork()的子进程下次会仅需循环n-2 次。。。。

其中常数1是进程本身。

边界条件,f(0)=1

这样,我们就得到了问题的答案:

f(n)=1+f(n-1)+f(n-2)+…+f(0)

f(0)=1

这个可以求出闭形式:

f(0)=1

f(1)=2

f(2)=4

…

用数学归纳法可以得到f(n)=2^n

所以对于程序一,会打印出2^5-1=31行信息。

对于程序二,总共会产生2^5=32个进程。

不过,我还是不知道为什么两个变量的结果怎么是那种形式的输出,求指导啊!!!

下面贴一下比较有意思的一段代码:

  1. #include <stdio.h>   
  2.   
  3. #include <unistd.h>   
  4.   
  5. int main(int argc, char* argv[])   
  6.   
  7. {   
  8.   
  9. fork();   
  10.   
  11. fork() && fork() || fork();         
  12.   
  13. fork();   
  14.   
  15. return 0;   
  16.   
  17. }   


我们要知道&& 和||运算符。&&有个短路现象。

A&&B,如果A=0,就没有必要继续执行&&B了;A非0,就需要继续执行&&B。
A||B,如果A非0,就没有必要继续执行||B了,A=0,就需要继续执行||B。

通过画图我们可以得到如下

加上前面的fork和最后的fork,总共4*5=20个进程,除去main主进程,就是19个进程了。


python多进程,multiprocessing和fork 最近使用python进行多进程开发,遇到问题:multiprocessing.Process的实例化必须放在if __name__ == "__main__"代码块或自定义函数中,这个问题涉及到以下知识点: __main__的作用、multiprocessing在windows下实现多进程的过程、unix下fork的原理,下面逐一解答。 先科普下进程的定义:程序的一次动态执行过程,包括代... 阅读详情

相关推荐

RimWorld Mod开发避坑指南:从Defs命名规范到XML结构详解(附实战代码)

本文深入解析RimWorld Mod开发中Defs文件的编写规范与高级技巧,涵盖命名冲突预防、XML结构优化及高级功能实现。通过实战代码示例,帮助开发者避开常见陷阱,提升Mod兼容性与稳定性,特别适合RimWorld Mod开发者参考。

weixin_30790841的博客 453

Unix环境高级编程--fork()

一个进程可以调用fork函数创建一个子进程。 如果是在子进程中则返回0,在父进程中则返回子进程的id,若出错则返回-1。pid_t是可以用于存储进程的id号的类型,进程的id号一般是一个正整数

欢迎一起交流问题! 479

ReelShort Android 逆向实战:Frida Hook 定位 sign 与 requestTime 算法

一个动态变化的 sign,如何从海量 so 逻辑中精准定位并完整复现?本文以海外短剧 App ReelShort 为例,实战拆解搜索、列表与详情接口的分析过程:从 Charles 抓包锁定关键参数,到 jadx 定位 native 函数,再借助 Frida Hook 验证加密结果;逐步还原 requestTime 的生成机制及 sign 的 HMAC-SHA256 签名逻辑。全文记录关键思路、踩坑与验证方法,带你建立一套可迁移的 Android 接口逆向分析流程。

weixin_64116813的博客 458

【再思考】linux中fork()函数详解

看到一个关于fork函数的题,其实真的是一知半解地没太理解,先放在这里,以便后续再思考 【出处】fork函数详解 【参考】http://coolshell.cn/articles/7965.html http://blog.youkuaiyun.com/wallwind/article/details/6996004 不算main这个进程自身,到底创建了多少个进程啊?

点点滴滴 633

PyQt5混搭qfluentwidgets实战:用FramelessWindow快速打造现代化界面

本文详细介绍了如何将PyQt5与qfluentwidgets组件库结合,利用FramelessWindow快速打造现代化无边框界面。通过环境配置、核心特性解析、组件混用技巧及高级样式定制,帮助开发者提升桌面应用的用户体验和美观度,特别适合需要现代UI设计的Python开发者。

sugar的博客 969

零基础做AI漫剧:Kimi K2.5写本 + Flux生图 + Seedance 2.0动效的保姆级教程

很多零基础小伙伴想做AI漫剧,却被“写剧本、画分镜、做动效”三大难题劝退——不会写剧情、不会画插画、不会做动态,觉得门槛太高。其实不用慌!今天就给大家带来保姆级教程,全程用Kimi K2.5(写剧本)、Flux(生分镜图)、Seedance 2.0(做动效)三个工具,不用专业技能,不用手动绘画,零基础也能在1小时内做出1分钟完整AI漫剧,全程步骤拆解、示例齐全,跟着做就能出片!

远程部署调试 运行安装 项目调试 二次开发 项目技术新 持续迭代 部分源码免费分享 3046

fork()进程创建的一道例题

fork 函数原型: pid_t fork(); 返回值: 若成功调用一次则返回两个值: 向子进程返回0, 向父进程返回子进程ID(大于0);否则,出错返回-1 函数说明: 一个现有进程可以调用fork函数创建一个新进程。由fork创建的新进程被称为子进程(child process)。 fork函数被调用一次但返回两次。两次返回的唯一区别是子进程中返回0值而父进程中返回子进程ID。 子进程是父进程的副本,它将获得父进程数据空间、堆、栈等资源的副本。 子进程持有的是上述存储空间的“副本”,这意味着父子进程

qq_39208237的博客 801

从自然语言到PCB设计:DeepSeek与Altium协同自动化实战指南

摘要:在电子设计领域,将自然语言需求转化为PCB设计图是实现自动化设计的重要目标。受限于当前NLP和EDA技术,通过DeepSeek直接生成完整PCB设计图尚无法实现,但在设计辅助环节已展现实用价值。本文深入分析技术可行性,提出"自然语言→设计约束→脚本生成→人工验证"的人机协同工作流。通过28个完整代码示例、12张技术图表及5个工程案例,详细展示DeepSeek解析需求、生成设计约束,并结合Altium Designer API实现元件放置、规则设置、DRC校验的全流程。

专注于人工智能、软件开发、工控自动化、工厂数字化及智能化等领域,希望和大家共同进步! 1774

Unix/Linux fork前传

本文是《Linux fork那些隐藏的开销》的前传。fork的由来fork的思想在UNIX出现几年前就出现了,时间大概是1963年,这比UNIX在PDP-7上的第一个版本...

Linux阅码场 38万+

华为OD机试双机位A卷 - 小明减肥 (C++ & Python & JAVA & JS & GO)

华为OD机试2025双机位A卷 小明减肥,提供Java、C++、Python、Go、JavaScript源码实现,并提供完整思路讲解

qq_45776114的博客 710

【python】懂车帝字体反爬逐层解密案例(附完整代码)

懂车帝字体反爬解密,完整代码分享

景天科技苑 2万+

unix多进程编程之fork函数笔记

unix多进程编程之fork函数笔记 运行环境:mac+xcode fork进程介绍fork函数是复制本进程的一个拷贝,生成该进程的子进程。两个进程相同的地方: 和该进程相关联的全部数据(包括变量,内存空间,缓冲区,文件描述符等等) 程序的执行上下文(execution context),两个进程会从fork后的相同位置开始继续执行 两个进程主要不同的地方: pid=fork();中的pid不同

绯浅yousa的笔记 878

「UG/NX」Block UI 曲线收集器CurveCollector

曲线收集器块用于选择一条或多条曲线,包括通过选择意图连接的末端曲线链。曲线选择意图用于此块,但它不支持“交点处停止”、“跟随圆角”、“中间链”和“特征内链”等规则选项。

何曾参静谧的博客 1092

UNIX C 多进程编程[转]

写在前面的话本文主要根据本人在UNIX系统上的编程实践经验总结而成, 既做为自己在一个时期内编程实践的部分总结, 又可成为文章发表. 对UNIX程序员初学者来说是一个小小的经验, 仅供参考; 对UNIX老手来说则不值一哂, 请各位多多指教.一.多进程程序的特点由于UNIX系统是分时多用户系统, CPU按时间片分配给各个用户使用, 而在实质上应该说CPU按时间片分配给各个进程使用, 每个进程都有自己

四毛的专栏 1363

霍尼韦尔SoftMaster使用说明

霍尼韦尔SoftMaster使用说明

精雕软件(JDpaint) 5.5 绿色版

精雕软件(JDpaint) 5.5 绿色版精雕软件(JDpaint) 5.5 绿色版精雕软件(JDpaint) 5.5 绿色版

Python多进程fork()函数详解

进程 进程是程序的一次动态执行过程,它对应了从代码加载、执行到执行完毕的一个完整过程。进程是系统进行资源分配和调度的一个独立单位。进程是由代码(堆栈段)、数据(数据段)、内核状态和一组寄存器组成。 在多任务操作系统中,通过运行多个进程来并发地执行多个任务。由于每个线程都是一个能独立执行自身指令的不同控制流,因此一个包含多个线程的进程也能够实现进程内多任务的并发执行。 进程是一个内核级的实体,...

人生苦短, 还不用Python? 736

visio安装包

Microsoft Office Visio 是一款专业的制图软件。利用经过更新的形状、协作工具和数据链接图表,创建专业级图表以简化复杂的信息。

python fork_Python多进程fork()函数详解

进程进程是程序的一次动态执行过程,它对应了从代码加载、执行到执行完毕的一个完整过程。进程是系统进行资源分配和调度的一个独立单位。进程是由代码(堆栈段)、数据(数据段)、内核状态和一组寄存器组成。在多任务操作系统中,通过运行多个进程来并发地执行多个任务。由于每个线程都是一个能独立执行自身指令的不同控制流,因此一个包含多个线程的进程也能够实现进程内多任务的并发执行。进程是一个内核级的实体,进程结构的所...

weixin_33404102的博客 750

TMS_WebGMaps_1.9.8.0_Full_Source

TMS_WebGMaps_1.9.8.0_Full_Source 全源码 delphi cbuilder

UNIX多进程编程

一.多进程程序的特点 由于UNIX系统是分时多用户系统, CPU按时间片分配给各个用户使用, 而在 实质上应该说CPU按时间片分配给各个进程使用, 每个进程都有自己的运行环境 以使得在CPU做进程切换时不会"忘记"该进程已计算了一半的"半成品". 以DOS 的概念来说, 进程的切换都是一次"DOS中断"处理过程, 包括三个层次: (1)用户数据的保存: 包括正文段(TEXT), 数据段(DATA,

小伟 2050

UNIX环境编程(c语言)--多进程(二)--多进程编程

APUE UNIX环境高级编程 多进程编程 创建新进程 fork 子进程可以在父进程得到的 vfork 函数 exit 、_exit函数 wait 和waitpid函数 waitid,wait3,wait4 exec 函数 system 函数 popen函数 多进程编程实例

GuanFuXin优快云的博客 1913
上一篇: 进程控制 [fork() exec() wait() waitpid()]
下一篇: 排序
天天向上zb
博客等级 码龄16年 34粉丝 43原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值