本文主要是介绍fork入门,希望对大家解决编程问题提供一定的参考价值,需要的开发者们随着小编来一起学习吧!
1哪个分支会打印
如下是fork的典型问题。fork之后有3个分支,分别是pid等于0,pid大于0,pid小于0。如果我们不了解fork的话,那么肯定会认为这里的if else分支只会有一个分支被执行。而实际的执行结果是两个分支都执行了。fork返回之后就创建了一个子进程,父进程在fork返回之后继续向下执行;子进程同样也是从fork返回之后开始执行。对于父进程来说,返回值是子进程的进程号,对于子进程来说,返回值是0。
fork创建一个进程,就类似于孕妈妈生孩子。将孕妈妈推进产房的时候是一个人,从产房出来的时候是两个人。孩子刚出生的时候共享父母的资源,比如房子,金钱等,fork创建的子进程也是共享着父进程的资源。
fork类似于产房,调用fork就相当于将孕妈妈推进了产房,父进程类似于孕妈妈,子进程类似于刚出生的孩子。
fork过程和现实世界有着高度的相似性。
#include <sys/types.h>
#include <unistd.h>int main() {pid_t pid = fork();if (pid == 0) {printf("pid is 0\n");} else if (pid > 0) {printf("pid > 0\n");} else {printf("pid < 0\n");}return 0;
}
2fork和pthread_create的区别
fork是创建一个新的进程,pthread_create是创建一个新的线程。直观来看,两者的区别是显而易见的。
进程和线程的区别:
进程是资源封装的单位,线程是调度的单位。进程的资源包括内存、打开的文件、信号等。以内存为例,之所以说进程是资源封装的单位,分配给一个进程的内存,只有这个进程是可以访问的,这个进程内的所有线程都共享进程的内存资源,而一个进程的内存,其它进程是不能访问的。
进程的资源:
进程号pid | 在一个进程内,不管在哪个线程中调用getpid,返回的pid都是一样的,都是所在的进程的进程号。 |
内存 | ①内存,最常讨论的是堆内存和栈内存,堆内存是属于进程的资源,一个进程内的所有线程共享;栈内存属于线程的资源。 ②全局变量是属于进程的资源,局部变量属于线程的资源。 所以说,并不是所有的内存都是线程共享的,栈内存就是一个线程专有的。 |
信号处理函数 | 当我们通过signal或sigaction注册某个信号的处理函数时,不管是在哪个线程中注册的,那么这个回调函数对于整个进程都是生效的。 |
打开的文件 | 打开的文件用一个fd来表示,打开的文件属于进程的资源。 |
进程是资源管理的基本单位,但是在父子进程之间,两者的资源也不是完全隔离的。不同的资源有不同的处理方式:内存是写时拷贝(cow, copy on write),fork之后,父子进程之间共享内存,当内存被写时,父子进程分家;信号处理函数、打开的文件、调度策略,子进程与父进程保持一致。
fork、exec踩坑记录
在用户态来看,fork和pthread_create是完全不相干的两个api,进程和线程的区别也是很清晰。fork和pthread_create都是用户态的api,两者最终都会调用同一个系统调用clone。在linux内核中,fork创建的进程和pthread_create创建的线程都是用一个struct task_struct来表示,区别就在于资源是不是共享,不共享则创建的是进程,共享则创建的是线程。
通过实际代码和strace来查看fork和pthread对clone的调用:
如下是fork代码,使用fork创建一个子进程。
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>int main() {sleep(2);printf("before fork\n");pid_t pid = fork();if (pid == 0) {for (int i = 0; i < 3; i++) {printf("child process, pid=%d\n", getpid());sleep(1);}} else if (pid > 0) {for (int i = 0; i < 3; i++) {printf("parent process, pid=%d\n", getpid());sleep(1);}}return 0;
}
如下是pthread的代码,c++中的std::thread最终也会通过pthread_create来创建一个线程。
#include <iostream>
#include <thread>
#include <unistd.h>void func() {
}int main() {sleep(2);std::cout << "before create thread\n";std::thread t(func);t.join();return 0;
}
使用 gcc fork.c -o fork和g++ thread.c -o thread分别编译上边的代码,然后使用strace来跟踪调用系统调用的情况。strace是linux的一个工具,可以打印应用调用的系统调用,同时也会打印出来形参和返回值。
如下两个截图分别显示了fork调用clone和pthread_create调用clone, 可以看到fork和pthread_create调用clone时,入参的个数和参数的内容都是不一样的。其中最主要的区别是第二个参数,pthread_create调用clone时,flag中的参数CLONE_VM,CLONE_FILES,CLONE_SIGHAND等标志,说明创建的这个线程与父线程共享这些资源。理论上来说,直接使用clone比较灵活,有多种参数的组合,但在实际项目中,没有这样的使用场景,也要尽量避免直接使用clone,使用不当很容易出错。fork和pthread_create均是用户态的api,而不是系统调用,clone才是系统调用。
fork调用clone:
pthread_create调用clone:
clone flag
clone最重要的一个形参就是flag,传入不同的flag可以决定子进程和父进程的哪些资源共享,哪些资源不共享。调用pthread_create的时候,flag中包括CLONE_VM、CLONE_FILES、CLONE_FS、CLONE_THREAD。这里的CLONE是共享的意思,而不是克隆一份全新的。
通过形参的方式来实现系统调用,这样可以使系统调用有很强的可扩展性,当需要支持不同的功能的时候,直接通过增加flag或者修改flag就可以。保证在系统调用不变的情况下,更改支持的功能,同时也能保持向下的兼容。通过man clone,也能看到clone支持很多个flag,这些flag都是在不同的linux版本中支持的。
CLONE_VM | 子进程和父进程共享内存,子进程修改了内存,父进程能看到;反之亦然。 |
CLONE_FILES | 子进程和父进程共享打开的文件,也就是共享进程的fd table。比如父进程中打开了一个tcp socket,一个tcp socket就是一个打开的文件,如果设置了这个标志,那么子进程中也可以使用;如果父进程或者子进程把这个fd关闭了,那么子进程和父进程都不能使用这个fd了。 这里要区分共享和继承的区别,对于打开的文件来说,现成会共享父线程的打开的fd,共享的话是一份,两者共用一份;fork的子进程会继承父进程的打开的fd,继承的话在父子进程中各有一份,这个时候如果只是父进程或者子进程把fd关闭了,那么不影响子进程或者父进程。 |
CLONE_FS | 共享文件系统,比如进程的工作目录或者文件系统的根目录。 |
CLONE_THREAD | 这个标志标识将新进程加入到和父进程相同的线程组中。 线程组可以看做就是一个进程,一个进程内的所有线程都属于一个线程组。 我们使用getpid获取进程id的时候,不管是在哪个线程中获取,那么获取的值都是相同的,这个值也叫线程组id,即TGID,thread group id。 |
3创建进程
创建一个进程的过程并不神秘。举一个我们在c语言中使用结构体的例子,当我们使用c语言的时候,经常使用结构体:使用malloc为结构体申请一块内存,然后再逐个对结构体的成员进行赋值,这是典型的使用步骤。
fork创建一个新的进程,本质上与使用结构体的方式是类似的。在内核中,进程用一个结构体struct task_struct来表示,fork中首先申请了一个struct task_struct,然后将结构体的属性进行初始化,最后将之加入到运行队列。简单来说分为3步:创建对象,初始化对象,使用对象。
使用结构体的例子:
#include <stdlib.h>
#include <stdio.h>
#include <string.h>struct Person {char *name;int age;
};int main() {struct Person *p = (struct Person *)malloc(sizeof(struct Person));if (p == NULL) {printf("p is null\n");return -1;}p->name = "xiaoming";p->age = 7;printf("name:%s,age:%d\n", p->name, p->age);return 0;
}
如果使用过c++,那么我们知道,c++中除了构造函数,还有拷贝构造函数以及移动构造函数。对于对象的拷贝来说,又分为浅拷贝和深拷贝,假如对象中有一个成员为char *数据类型,那么拷贝的时候只拷贝指针,就是浅拷贝;拷贝的时候如果将char *指针中的内容都拷贝,那么就是深拷贝。
fork可以看做是构造一个进程,构造进程的过程类似于c++中的浅拷贝。以内存为例,fork之后,子进程会共享父进程的内存资源,并不是把父进程内存中的内容都拷贝了一份到子进程中。当内存被写时,这个时候父子进程的内存才会分家,又称写时拷贝。
3.1kernel_clone
fork的工作都是在函数kernel_clone中完成,kernel_clone做的事情分为3步:
(1)首先,要进行参数检查,主要检查flag的设置,有没有冲突的地方,如果参数检查不通过,则返回错误;否则,进行下一步。
(2)copy_process,这也是最重要的一步,创建一个struct task_struct,然后对结构体成员进行初始化化,从copy_process的名字也可以看出,主要是拷贝,新进程的内容,大部分是从父进程的task_struct中拷贝而来。
(3)进程已经创建,最后就是将进程唤醒,唤醒之后,进程就可以运行了。
pid_t kernel_clone(struct kernel_clone_args *args)
{//1.参数检查if ((args->flags & CLONE_PIDFD) &&(args->flags & CLONE_PARENT_SETTID) &&(args->pidfd == args->parent_tid))return -EINVAL;if (!(clone_flags & CLONE_UNTRACED)) {if (clone_flags & CLONE_VFORK)trace = PTRACE_EVENT_VFORK;else if (args->exit_signal != SIGCHLD)trace = PTRACE_EVENT_CLONE;elsetrace = PTRACE_EVENT_FORK;if (likely(!ptrace_event_enabled(current, trace)))trace = 0;}//2.copy_processp = copy_process(NULL, trace, NUMA_NO_NODE, args);//3.唤醒进程wake_up_new_task(p);return nr;
}
3.2copy_process
我的内核代码版本是5.10.186, copy_process函数有542行,fork的核心工作都是在copy_process中完成的。
copy_process中做的主要工作如下:
(1)参数检查
①在不同的命名空间下或者不同的用户下,不允许共享文件系统。
②如果标志中有CLONE_THREAD,说明创建的是一个线程,线程要和创建它的进程共享信号处理函数。
③如果共享信号处理函数,但是没有共享VM,也就是内存,这样是不允许的。
/** Don't allow sharing the root directory with processes in a different* namespace*/if ((clone_flags & (CLONE_NEWNS|CLONE_FS)) == (CLONE_NEWNS|CLONE_FS))return ERR_PTR(-EINVAL);if ((clone_flags & (CLONE_NEWUSER|CLONE_FS)) == (CLONE_NEWUSER|CLONE_FS))return ERR_PTR(-EINVAL);/** Thread groups must share signals as well, and detached threads* can only be started up within the thread group.*/if ((clone_flags & CLONE_THREAD) && !(clone_flags & CLONE_SIGHAND))return ERR_PTR(-EINVAL);/** Shared signal handlers imply shared VM. By way of the above,* thread groups also imply shared VM. Blocking this case allows* for various simplifications in other code.*/if ((clone_flags & CLONE_SIGHAND) && !(clone_flags & CLONE_VM))return ERR_PTR(-EINVAL);...
(2)dup_task_struct,创建一个新的task_struct并初始化
在这个函数中首先申请一个task_struct,然后将父进程的task_struct拷贝到新申请的task_struct,然后返回新申请的task_struct,这个新的task_struct就表示新创建的进程。从dup_task_struct函数的名字也可以看出来,是对task_struct的复制。该函数调用之后子进程的task_struct和父进程的task_struct是完全一样。
在该函数之后,会对新的task_struct进行修改,一个最直接的例子就是新进程的pid和父进程pid肯定是不一样的,要单独进行设置。
(3)设置pid
/* ok, now we should be set up.. */p->pid = pid_nr(pid);
(4)资源拷贝
调用了很多以copy开头的函数,对资源进行拷贝。如下是对打开的文件进行拷贝的,在该函数中首先要检查是不是设置了CLONE_FILES,如果设置了,说明要和父进程共享,直接将父进程的引用计数加1;否则,通过dup_fd对打开的文件进行拷贝。从这里可以看到clone和copy的区别,前者是共享,后者是拷贝一份。
static int copy_files(unsigned long clone_flags, struct task_struct *tsk)
{
...if (clone_flags & CLONE_FILES) {
atomic_inc(&oldf->count);
goto out;
}
newf = dup_fd(oldf, NR_OPEN_MAX, &error);
if (!newf)
goto out;
tsk->files = newf;
error = 0;
out:
return error;
}
retval = copy_semundo(clone_flags, p);if (retval)goto bad_fork_cleanup_security;retval = copy_files(clone_flags, p);if (retval)goto bad_fork_cleanup_semundo;retval = copy_fs(clone_flags, p);if (retval)goto bad_fork_cleanup_files;retval = copy_sighand(clone_flags, p);if (retval)goto bad_fork_cleanup_fs;retval = copy_signal(clone_flags, p);if (retval)goto bad_fork_cleanup_sighand;retval = copy_mm(clone_flags, p);if (retval)goto bad_fork_cleanup_signal;retval = copy_namespaces(clone_flags, p);if (retval)goto bad_fork_cleanup_mm;retval = copy_io(clone_flags, p);if (retval)goto bad_fork_cleanup_namespaces;
(5)copy_thread
copy_thread是一个和cpu架构有关的函数,每个cpu架构都实现了自己的copy_thread,在其中主要的工作是设置线程的栈信息。这个函数中做了很重要的事情,我们非常关心的两个问题都是在这个函数中做的:
①fork之后,子进程的返回值为什么是0?
返回值保存在一个特定的寄存器中,在copy_thread中将该寄存器设置为0,那么返回值就为0。
②子进程执行的第一条指令是哪个,也就是说子进程是从哪条指令开始执行的?
在copy_thread中设置新进程第一个执行的函数为ret_from_fork,该函数从内核空间返回到用户空间。
这篇关于fork入门的文章就介绍到这儿,希望我们推荐的文章对编程师们有所帮助!