scheduler02

fork()、vfork()、pthread_create()

测试环境：

ubuntu 10.04 ( linux 2.6.32 )

测试：

$ cat test.c
#include <sched.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>

int data = 10;

int child_process()
{
    printf("Child process %d, data %d\n",getpid(),data);
    data = 20;
    printf("Child process %d, data %d\n",getpid(),data);
    _exit(0);
}

int main(int argc, char* argv[])
{
    int pid;
    // pid = fork();
    // pid = vfork();

    if(pid==0) {
        child_process();
    }
    else{
        sleep(1);
        printf("Parent process %d, data %d\n",getpid(), data);
        exit(0);
    }
}

$ gcc test.c -o test

# 当pid = fork();时
$ ./test
Child process 2646, data 10
Child process 2646, data 20
Parent process 2645, data 10
$ strace ./test
...
clone(child_stack=x, flags=CLONE_CHILD_CLEARTID|CLONE_CHILD_SETTID|SIGCHLD, child_tidptr=xxx)
...

# 当pid = vfork();时
$ ./test
Child process 2702, data 10
Child process 2702, data 20
Parent process 2701, data 20
$ strace ./test
xxxxx

$ cat thread.c 
#include <stdio.h>
#include <pthread.h>
#include <stdio.h>
#include <linux/unistd.h>
#include <sys/syscall.h>

int data = 10;

static pid_t gettid( void )
{
    return syscall(__NR_gettid);
}

static void *thread_fun(void *param)
{
    data = 20;

    printf("thread pid:%d, tid:%d pthread_self:%lu\n", getpid(), gettid(),pthread_self());
    printf("data %d\n", data);
    return NULL;
}

int main(void)
{
    pthread_t tid;
    int ret;

    printf("thread pid:%d, tid:%d pthread_self:%lu\n", getpid(), gettid(),pthread_self());
    printf("data %d\n", data);

    ret = pthread_create(&tid, NULL, thread_fun, NULL);
    if (ret == -1) {
        perror("cannot create new thread");
        return -1;
    }

    if (pthread_join(tid, NULL) != 0) {
        perror("call pthread_join function fail");
        return -1;
    }

    printf("thread pid:%d, tid:%d pthread_self:%lu\n", getpid(), gettid(),pthread_self());
    printf("data %d\n", data);

    return 0;
}
$ gcc thread.c -pthread -o thread
$ ./thread
thread pid:1878, tid:1878 pthread_self:140648953210624
data 10
thread pid:1878, tid:1879 pthread_self:140648945157904
data 20
thread pid:1878, tid:1878 pthread_self:140648953210624
data 20
$ strace ./thread
...
clone(child_stack=xxx,flags=CLONE_VM|CLONE_FS|CLONE_FILES|CLONE_SIGHAND|CLONE_THREAD|CLONE_SYSVSEM|CLONE_SETTLS|CLONE_PARENT_SETTID|CLONE_CHILD_CLEARTID, parent_tidptr=xxx,tls=xxx, child_tidptr=xxx) = xxx
...

总结：

用户空间 -------------------------->  内核空间
fork()           -> clone(flag) -> do_fork(flag)
vfork()          -> clone(flag) -> do_fork(flag)
pthread_create() -> clone(flag) -> do_fork(flag)

如上图，无论创建进程还是线程，都是调用系统调用clone ()，再调用内核函数do_fork()创建struct task_strust，唯一不同是它们传递flag标志不同，以区分哪些资源是否共享等等。

linux使用 fork() 创建进程时，父进程与子进程共享同一个资源，即struct task_strust 指向同一个资源，并此时所有资源都以只读方式共享。只有父进程或子进程其中一个对资源进行写操作时，linux才会为父进程或子进程创建复制一份一模一样的资源，即此时父子进程才各自拥有一份完全不同的struct task_strust，对资源都拥有读写权限。这就是进程写时拷贝(Copy-on-Write)技术。

linux使用 vfork() 创建进程时，跟fork() 创建进程基本是一样的，唯一不同是task_strust->mm成员是共享，如进程中全局变量是共享。

linux使用pthread_create()创建线程时，进程内所有线程共享同一个资源，即 struct task_strust 指向同一个资源，所有资源都以读写方式共享。

为什么线程称为轻量级进程？

从上述可知，在linux kernel中，进程与线程都是用struct task_strust 表示，唯一不同是 struct task_strust 指向资源是否共享。

进程1和进程0

测试环境：

ubuntu 10.04 ( linux 2.6.32 )

ubuntu 20.04 ( linux 5.4.0)

测试：

$ uname -r
2.6.32-21-generic
$ ls -l /sbin/init
-rwxr-xr-x 1 root root 125704 2010-04-02 08:13 /sbin/init
$ cat /proc/1/status
Name:    init
Tgid:    1
Pid:    1
PPid:    0
...

vernon@vernon-VB:/proc$ pstree
init─┬─NetworkManager─┬─dhclient
     │                └─{NetworkManager}
     ├─acpid
     ├─atd
     ├...

#####################################################

$ uname -r
5.4.0-47-generic
$ ls -l /sbin/init 
lrwxrwxrwx 1 root root 20 7月   7 05:38 /sbin/init -> /lib/systemd/systemd
$ cat /proc/1/status 
Name:    systemd
Tgid:    1
Pid:    1
PPid:    0
...
$ pstree
systemd─┬─ModemManager───2*[{ModemManager}]
        ├─NetworkManager───2*[{NetworkManager}]
        ├─accounts-daemon───2*[{accounts-daemon}]
        ├─acpid
        ├...

总结：

init进程是整个系统的第一个进程，也就是1号进程。

1号进程有父进程 0号进程，即 idle进程

孤儿进程

测试环境：

ubuntu 10.04 ( linux 2.6.32 )

ubuntu 20.04 ( linux 5.4.0)

测试：

$ cat life_period.c 
#include <stdio.h>
#include <sys/wait.h>
#include <stdlib.h>
#include <unistd.h>

int main(void)
{
    pid_t pid,wait_pid;
    int status;

    pid = fork();

    if (pid==-1)    {
        perror("Cannot create new process");
        exit(1);
    } else if (pid==0) {
        printf("child process id: %ld\n", (long) getpid());
        pause();
        _exit(0);
    } else {
        printf("parent process id: %ld\n", (long) getpid());
        wait_pid=waitpid(pid, &status, WUNTRACED | WCONTINUED);
        if (wait_pid == -1) {
            perror("cannot using waitpid function");
            exit(1);
        }

        if(WIFSIGNALED(status))
            printf("child process is killed by signal %d\n", WTERMSIG(status));

        exit(0);
    }
}

#####################################################

$ uname -r
2.6.32-21-generic
$ gcc life_period.c
$ ./a.out
parent process id: 1795
child process id: 1796
$ pstree
init─┬─NetworkManager─┬─dhclient
     │                └─{NetworkManager}
     ├─acpid
     |.......
     ├─gnome-terminal─┬─bash───a.out───a.out
     │                ├─2*[bash]
     │                ├─gnome-pty-helpe
     │                └─{gnome-terminal}
     ├─gvfs-afc-volume───{gvfs-afc-volum}

$ kill 1795
$ pstree
init─┬─NetworkManager─┬─dhclient
     │                └─{NetworkManager}
     ├─a.out
     ├─acpid
     |.......
     ├─gnome-terminal─┬─3*[bash]
     │                ├─gnome-pty-helpe
     │                └─{gnome-terminal}
     ├─gvfs-afc-volume───{gvfs-afc-volum}

#####################################################

$ uname -r
5.4.0-47-generic
$ ./a.out 
parent process id: 6323
child process id: 6324
$ pstree
systemd─┬─ModemManager───2*[{ModemManager}]
        ├....
        ├─systemd─┬─(sd-pam)
        │         ├......
        │         ├─gnome-terminal-─┬─bash───a.out───a.out
        │         │                 ├─bash───pstree
        │         │                 └─5*[{gnome-terminal-}]
$ kill 6323
$ pstree
systemd─┬─ModemManager───2*[{ModemManager}]
        ├....
        ├─systemd─┬─(sd-pam)
        │         ├......
        │         ├─a.out
        │         ├─gnome-terminal-─┬─2*[bash]
        │         │                 ├─bash───pstree
        │         │                 └─5*[{gnome-terminal-}]

总结：

当子进程先死亡时，父进程负责得到子进程死亡原因以及清除struct task_strust

当父进程先死亡时，子进程变成孤儿进程，此时linux系统需要给子进程找一个养父进程。在linux 3.4之前，养父进程一般都是init进程；在linux 3.4之后，养父进程一般都是SUBREAPER标志的进程，如上图每一个用户的systemd进程就是用SUBREAPER标志的进程。

进程睡眠

测试环境：

宋宝华老师的驱动开发书－－ globalfifo.c

测试：

static ssize_t globalfifo_write(struct file *filp, const char __user *buf,
                    size_t count, loff_t *ppos)
{
    DECLARE_WAITQUEUE(wait, current);

    add_wait_queue(&dev->w_wait, &wait);
    ...
    __set_current_state(TASK_INTERRUPTIBLE);
    schedule();
    ...
}

总结：

进程进入睡眠状态，可分为两种：深度睡眠与浅度睡眠。

深度睡眠，即UNINTERRUPTIBLE_SLEEP，只有当所需资源到达时，进程才被唤醒。

浅度睡眠，即INTERRUPTIBLE_SLEEP，当所需资源或信号到达时，进程才被唤醒。

进程进入睡眠状态，即调用add_wait_queue()将进程放入等待队列中，设置为__set_current_state(UNINTERRUPTIBLE_SLEEP)或__set_current_state(INTERRUPTIBLE_SLEEP)后，调用schedule()。此时进程放弃CPU，CPU调度另一个进程继续执行。当所需资源或信号到达时，通过调用wake_up()唤醒进入睡眠状态的进程，从schedule()下一行源码继续执行。

Previousscheduler01 Nextscheduler03

Last updated 4 years ago

Was this helpful?

fork()、vfork()、pthread_create()

为什么 线程称为轻量级进程？

进程1和进程0

孤儿进程

进程睡眠

为什么线程称为轻量级进程？