进程最细教程

进程 Process

1. 什么是进程

进程和程序的区别

1.1 概念

程序：编译好的可执行文件

存放在磁盘上的指令和数据的有序集合（文件）

程序是静态的，没有任何执行的概念

进程：一个独立的可调度的任务

执行一个程序所分配资源的总成

进程是程序一次执行的过程

进程是动态的，包括创建、调度、执行和消亡

1.2 特点

1. 系统会为每一个进程分配0-4g虚拟空间，其中0-3g(用户空间)是每个进程所独有，3g-4g(内核空间)是所有进程共有的。

进程间通信可以借助公用的内核空间：

1. CPU调度进程时会给进程分配时间片(几毫秒~十几毫秒),当时间片用完后，cpu再进行其他进程的调度，实现进程的轮转，从而实现多任务的操作。

进程控制块task_struct

• 进程控制块pcb:包含描述进程的相关信息
• 进程标识PID：唯一的标识一个进程

主要进程标识：

进程号（PID: Process Identity Number）

父进程号：（Parent Process ID: PPID）

• 进程用户
• 进程状态、优先级
• 文件描述符（记录当前进程打开的文件）

1.3 进程段

Linux中的进程大致包含三个段：

数据段：存放的是全局变量、常数以及动态数据分配的数据空间(如malloc函数取得的空间)等。

正文段：存放的是程序中的代码

堆栈段：存放的是函数的返回地址、函数的参数以及程序中的局部变量 （类比内存的栈区）

1.4 进程的分类

交互进程：该类进程是由shell控制和运行的。交互进程既可以在前台运行，也可以在后台运行。该类进程经常与用户进行交互，需要等待用户的输入，当接收到用户的输入后，该类进程会立刻响应，典型的交互式进程有：shell命令进程、文本编辑器等

批处理进程：该类进程不属于某个终端，它被提交到一个队列中以便顺序执行。(目前接触不到)

守护进程：该类进程在后台运行。它一般在Linux启动时开始执行，系统关闭时才结束。

1.5 进程状态

D uninterruptible sleep (usually IO) 不可中断的睡眠态

R running or runnable (on run queue) 运行态

S interruptible sleep (waiting for an event to complete) 可中断的睡眠态

T stopped by job control signal 暂停态

t stopped by debugger during the tracing 因为调试而暂停

X dead (should never be seen) 死亡态

Z defunct ("zombie") process, terminated but not reaped by its parent 僵尸态

< high-priority (not nice to other users) 高优先级

N low-priority (nice to other users) 低优先级

L has pages locked into memory (for real-time and custom IO) 锁在内存中

s is a session leader 会话组组长

l is multi-threaded (using CLONE_THREAD, like NPTL pthreads do)多线程

+ is in the foreground process group 前台进程

没有+时，默认是后台进程

I 空闲状态进程

1.6 进程状态切换图

进程创建后，进程进入就绪态，当CPU调度到此进程时进入运行态，当时间片用完时，此进程会进入就绪态，如果此进程正在执行一些IO操作(阻塞操作)会进入阻塞态，完成IO操作（阻塞结束）后又可进入就绪态，等待CPU的调度，当进程运行结束即进入结束态。

1.7 调度进程命令

ps 查看系统和中的进程 -aux -ef

top 动态查看系统中运行的进程

renice 改变正在运行进程的优先级

nice 按用户指定的优先级去运行进程

kill 给进程发信号

fg 将进程切换到前台执行

bg 将进程切换到后台执行

jobs 查看所有后台的进程

1. 进程函数接口

2.1 创建进程 fork()

man 2 fork

pid_t fork(void);
功能：创建子进程
返回值：
    成功：在父进程中：返回子进程的进程号 >0
         在子进程中：返回值为0
    失败：-1并设置errno

#include<unistd.h>
#include<stdio.h>
int main(int argc, char const *argv[])
{
    pid_t pid = fork(); //创建子进程
    if(pid < 0)
    {
        perror("fork err");
        return -1;
    }
    else if(pid == 0)
    {
        printf("i am child process\n");
        while(1);
    }
    else
    {
        sleep(1); //如果想让儿子先打印，可以让父亲先睡眠一会。
        printf("i am parent process\n");
        while(1);
    }
    return 0;
}

解释：fork()函数之前只有一个进程，fork()函数相当于在这个进程中又开启的一个进程并且把代码以及数据信息拷贝了一份，这两个进程只有个别数据例如进程号不一样。

如果没有干预情况，CPU会随机调度进程。

特点：

1）子进程几乎拷贝了父进程的全部内容。包括代码、数据、系统数据段中的pc值、栈中的数据、父进程中打开的文件等；但它们的PID、PPID是不同的。

2）父子进程有独立的地址空间，互不影响；当在相应的进程中改变全局变量、静态变量，都互不影响。

1. 若父进程先结束，子进程成为孤儿进程，被init进程收养，子进程变成后台进程。

#include <unistd.h>
#include <stdio.h>

int main(int argc, char const *argv[])
{
    int a = 10;
    pid_t pid = fork(); //创建子进程

    if (pid < 0)
    {
        perror("fork err");
        return -1;
    }
    else if (pid == 0)
    {
        a = 100;
        printf("i am child process: a= %d\n", a);
        while (1)
            ;
    }
    else
    {
        sleep(1); 
        printf("i am parent process:a= %d \n", a); //父进程先结束，子进程会变成孤儿进程被init进程收养
    }
    return 0;
}

孤儿进程被init进程收养了

1. 若子进程先结束，父进程如果没有及时回收，子进程变成僵尸进程（要避免僵尸进程产生）

2.2 回收资源

pid_t wait(int *status);

功能：回收子进程资源(阻塞)

参数：status：子进程退出状态，不接受子进程状态设为NULL

返回值：成功：回收的子进程的进程号

失败：-1

pid_t waitpid(pid_t pid, int *status, int options);

功能：回收子进程资源

参数：

pid：>0 指定子进程进程号

=-1 任意子进程

=0 等待其组ID等于调用进程的组ID的任一子进程

<-1 等待其组ID等于pid的绝对值的任一子进程

status：子进程退出状态

options：0：阻塞 WNOHANG：非阻塞

返回值：正常：结束的子进程的进程号

当使用选项WNOHANG且没有子进程结束时：0

出错：-1

#include <unistd.h>
#include <stdio.h>
#include <sys/types.h>
#include <sys/wait.h>

int main(int argc, char const *argv[])
{
    int a = 10;
    pid_t pid = fork(); //创建子进程

    if (pid < 0)
    {
        perror("fork err");
        return -1;
    }
    else if (pid == 0)
    {
        sleep(1);
        printf("i am child process: a= %d\n", a);
    }
    else
    {
        printf("i am parent process:a= %d \n", a);
        //wait(NULL);
        //waitpid(-1,NULL,0); //0:阻塞， 此时和wait(NULL)一样
        //waitpid(-1,NULL,WNOHANG); //WNOHANG：非阻塞，此时有可能接收不到子进程资源从而产生僵尸
        while (1) //所以要用循环回收资源，直到回收到了则退出
        {
            if(waitpid(-1,NULL,WNOHANG)>0)
                break;
        }
        printf("parent\n");
        while(1);
    }
    return 0;
}

2.3 结束进程

void exit(int status);
功能：结束进程，刷新缓存
void _exit(int status);
功能：结束进程，不刷新缓存
参数：status是一个整型的参数，可以利用这个参数传递进程结束时的状态。
    通常0表示正常结束；
其他的数值表示出现了错误，进程非正常结束

#include <unistd.h>
#include <stdio.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <stdlib.h>

int main(int argc, char const *argv[])
{
    printf("hello");
   // exit(0); //结束进程，刷新缓存
    _exit(0); //进程结束，没刷新缓存
    while(1);
    //思考：exit和return的区别
    return 0;
}

exit是结束进程，return是结束当前函数。

2.4 获取进程号函数

pid_t getpid(void);
功能：获取当前进程的进程号
pid_t getppid(void);
功能：获取当前进程的父进程号

可以看出现在展现给我们的有三个进程：先调度父进程，再调度打印hq@Ubuntu: 这条语句的进程，最后调度了执行子进程。怎么调度是CPU随机分配的。

1. exec 函数族（了解）

对于初学者可不做掌握，今后在工作项目中可能会遇到，到时候再补充掌握也可。

在一个进程中执行另一个进程：

system("ls -l");

system("clear");

#include <unistd.h>
#include <stdio.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <stdlib.h>

int main(int argc, char const *argv[])
{
    printf("hello\n");
    //system("ls -l");
    execl("/bin/ls","ls","-l",NULL); //该进程完全替换了原来的进程，所以后面不打印了
    printf("bye~\n");

    return 0;
}

1. 守护进程 Daemon

Linux以会话(session)、进程组的方式管理进程，每个进程属于一个进程组，也就是多个进程组成一个进程组。会话是一个或多个进程组的集合，通常用户打开一个终端时，系统会创建一个会话。所有通过该终端运行的进程都属于这个会话。终端关闭时，所有相关进程会被结束。

但是守护进程却能突破这种限制，不受终端关闭的影响。

3.1 守护进程特点

守护进程是后台进程

生命周期比较长，从系统开启时开启，系统和关闭时结束。

它是脱离终端控制切周期执行的进程。

3.2 创建步骤

1. 创建子进程，父进程退出

让子进程变成孤儿进程，成为后台进程; fork()

1. 让子进程中创建新会话

让子进程成为会话组组长并且脱离终端：为了让子进程完全脱离终端；setsid()

1. 改变进程运行路径为根目录

原因： 进程运行的路径不能被删除或卸载; chdir("/");

1. 重设文件权限掩码

目的：增大进程创建文件时权限，提高灵活性; umask(0)

子进程继承了父进程的文件权限掩码，给该子进程使用文件带来一定的影响，因此把文件 权限掩码设置为0，可以增强该守护进程的灵活性。

1. 关闭文件描述符

原因：子进程继承了父进程的一些已经打开了的文件，这些被打开的文件可能永远不会被守护进程访问，但它们一样占用系统资源，而且还可能导致所在的文件系统无法被卸载。

将不需要的文件关闭：close()

#include <unistd.h>
#include <sys/types.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/stat.h>

int main(int argc, char const *argv[])
{
    pid_t pid = fork();
    if (pid < 0)
    {
        perror("fork err");
        return -1;
    }
    if (pid == 0)
    {
        setsid();
        chdir("/");
        umask(0);
        for (int i = 0; i < 3; i++) //关闭默认打开的0 1 2
            close(i);
        while (1)
            ;
    }
    else
    {
        exit(0);
    }
    return 0;
}