IO进程——进程引入、进程函数接口

一、引入

1、进程&程序

1.1 程序

编译好的可执行的文件

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

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

1.2 进程

一个独立的可调度的任务

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

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

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

2、进程特点

（1）系统会为每一个进程分配0-4g的虚拟空间，0-3g（用户空间）是每个进程所独有的，3-4g（内核空间）是所有进程共有的 （32位系统）

进程间通信：

==>

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

没有外界干预的情况下，CPU随机分配调度进程，也就是先调度谁后调度谁随机

进程控制块task_struct(了解)

进程控制块pcb:包含描述进程的相关信息

进程标识PID：唯一的标识一个进程

主要进程标识：

进程号（PID: Process Identity Number）

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

进程用户

进程状态、优先级

文件描述符（记录当前进程打开的文件）

3、进程段

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

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

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

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

4、分类

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

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

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

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 (大写i)空闲状态进程

6、进程状态 切换图

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

什么是阻塞和非阻塞？

阻塞(blocking)、非阻塞（non-blocking)：可以简单理解为需要做一件事能不能立即得到返回应答，如果不能立即获得返回，需要等待，那就阻塞了，在等待的过程中可以做其它事情。否则就可以理解为非阻塞。

7、进程相关命令

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

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

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

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

kill 给进程发送信号

fg 将进程切换到前台执行

bg 将进程切换到后台执行

jobs 查看当前终端的后台进程

补充：优先级调度

根据进程的优先级进行调度，优先级高的进程先执行。

两种类型：

1、非剥夺式（非抢占式）优先级调度算法。当一个进程正在处理上运行时，即使有某个更为重要或紧迫的进程进入就绪队列，仍然让正在进行的进程继续运行，直到由于其自身原因而主动让出处理机（任务完成或等待事件），才把处理机分配给更为重要或紧迫的进程。

2、剥夺式（抢占式）优先级调度算法。当一个进程正在处理机上运行时，若有某个更为重要或紧迫的进程进入就绪队列，则立即暂停正在运行的进程，将处理机分配给更重要或紧迫的进程。

笔试题：

1、下列关于轮询任务调度和可抢占式调度区别描述错误的是?（ D ）

A. 抢占式调度实现相对较复杂且可能出现低优先级的任务长期得不到调度

B. 轮询调度不利于后面的请求及时得到响应

C. 抢占式调度有利于后面的高优先级的任务也能及时得到响应

D. 抢占式调度优点是其简洁性，它无需记录当前所有连接的状态

解析：抢占式调度相对复杂，需要记录和管理任务的优先级、状态等信息

2、会导致进程从执行态变为就绪态的事件是（ D ）。

A. 执行P（wait）操作

B. 申请内存失败

C. 启动I/O设备

D. 被高优先级进程抢占

3、分配到必要的资源并获得处理机时的进程状态是（ B ）。

A. 就绪状态

B. 执行状态

C. 阻塞状态

二、进程函数接口

1、创建子进程

#include <sys/types.h>

#include <unistd.h>

pid_t fork(void);

功能：创建子进程

返回值：

成功：

在父进程中 ===> 返回子进程的进程号 >0

在子进程中 ===> 返回值为0

失败：-1并设置errno

#include <sys/types.h>
#include <unistd.h>
#include<stdio.h>
int main(int argc, char const *argv[])
{
    // 创建子进程，子进程中返回0，父进程返回子进程的PID
    pid_t pid = fork();    
    if (pid < 0)    // 容错判断
    {
        perror("fork err");
        return -1;
    }
    else if (pid == 0)    // 子进程
        printf("child\n");
    else    // 父进程
        printf("parent\n");
    while (1);    // 让父子进程都进入死循环不结束
    return 0;
}

解释：./a.out会启动一个进程，执行到fork()函数时会在当前进程中创造了一个子进程并把代码以及数据信息拷贝到子进程，这两个进程只有个别数据例如进程号以及fork的返回值不一样，此时这两个进程由CPU随机调度。注意!!子进程会得到fork函数返回值然后执行fork之后的代码，fork函数之前的代码不会执行 。

●特点

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

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

#include <sys/types.h>
#include <unistd.h>
#include<stdio.h>
int main(int argc, char const *argv[])
{
    int a = 10;    // 定义变量a
    pid_t pid = fork();
    if (pid < 0)
    {
        perror("fork err");
        return -1;
    }
    else if (pid == 0)
    {        
        a = 20;    // 子进程中修改了a的值，不会影响父进程中a的值
        printf("child:%d, ip:%p\n", a, &a);
    }
    else
        printf("parent:%d, ip:%p\n", a, &a);
    while (1);
    return 0;
}

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

#include <sys/types.h>
#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("child\n");
        while (1);    // 让父进程先结束，子进程先不结束
    }
    else    // 父进程
        printf("parent\n");
    return 0;
}

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

#include <sys/types.h>
#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("child\n");
    else    // 父进程
    {        
        printf("parent\n");
        while (1);    // 让子进程结束，父进程不结束
    } 
    return 0;
}

2、回收资源

2.1 wait

#include <sys/types.h>

#include <sys/wait.h>

pid_t wait(int *status);

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

参数：

status ===> 子进程退出状态，不接受子进程状态设为NULL

返回值：成功：回收的子进程的进程号 失败：-1

#include <sys/types.h>
#include <unistd.h>
#include <sys/wait.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("child\n");
        sleep(3);    // 子进程睡眠3秒后再结束
     }
    else    // 父进程
    {        
        printf("parent\n");
        wait(NULL);   
    // 阻塞父进程等待回收子进程资源，子进程结束后才能结束阻塞成功回收
        printf("after wait\n");
        while (1);
    } 
    return 0;
}

运行程序并查看进程状态，此时会发现没有僵尸态进程

2.2 waitpid

#include <sys/types.h>

#include <sys/wait.h>

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 <sys/types.h>
#include <unistd.h>
#include <sys/wait.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("child\n");
        sleep(3);    // 子进程睡眠3秒后再结束
     }
    else    // 父进程
    {        
        printf("parent\n");  
        // waitpid(-1, NULL, 0);    
        /*0代表阻塞接收子进程资源，此时和wait(NULL)一样*/
        waitpid(-1, NULL, WNOHANG); // WNOHANG:代表非阻塞
        printf("after wait\n");        
        while (1);
    } 
    return 0;
｝

2.3 练习

实现waitpid设置非阻塞WNOHANG也可以接收到子进程资源

#include <sys/types.h>
#include <unistd.h>
#include <sys/wait.h>
#include<stdio.h>
int main(int argc, char const *argv[])
{
    int n = 0;
    pid_t pid = fork();
    if (pid < 0)
    {
        perror("fork err");
        return -1;
    }
    else if (pid == 0)  // 子进程  
    {        
        printf("child\n");
        sleep(3);    // 子进程睡眠3秒以后结束
    }
    else    // 父进程
    {        
        printf("parent\n");
        while (1)    // 使用轮询
        {
            // 直到接收到子进程资源则退出循环
            if (waitpid(-1, NULL, WNOHANG) > 0)
                break;
        }
        while (1);
    } 
    return 0;
}

#include <sys/types.h>
#include <unistd.h>
#include <sys/wait.h>
#include<stdio.h>
int main(int argc, char const *argv[])
{
    int n = 0;
    pid_t pid = fork();
    if (pid < 0)
    {
        perror("fork err");
        return -1;
    }
    else if (pid == 0)  // 子进程  
    {        
        printf("child\n");
        sleep(3);
    }
    else    // 父进程
    {        
        printf("parent\n");
        while ((n = waitpid(-1, NULL, WNOHANG)) <= 0)
        {
            if (n == -1)
                return -1;
        }
        while (1);
    } 
    return 0;
}

3、结束进程

3.1 exit

#include <stdlib.h>

void exit(int status);

功能：结束进程，刷新缓存

#include<stdio.h>
#include <stdlib.h>
int main(int argc, char const *argv[])
{
    printf("hello");
    exit(0);    // 刷新缓存
    while (1);
    return 0;
}

3.2 _exit

#include <unistd.h>

void _exit(int status);

功能：结束进程，不刷新缓存

参数：status是一个整型的参数，可以利用这个参数传递进程结束时的状态。

通常0表示正常结束；

其他的数值表示出现了错误，进程非正常结束

#include<stdio.h>
#include <unistd.h>
int main(int argc, char const *argv[])
{
    printf("hello");
    _exit(0);    // 不刷新缓存
    while (1);
    return 0;
}

3.3 return和exit区别

#include<stdio.h>
int fun()
{
    printf("in fun\n");
    return 0;    // 结束当前函数，in main还会正常显示
}
int main(int argc, char const *argv[])
{
    fun();
    printf("in main\n");
    return 0;
}

#include<stdio.h>
#include<stdlib.h>
int fun()
{
    printf("in fun\n");
    exit(0);    // 直接结束进程，in main不会显示
}
int main(int argc, char const *argv[])
{
    fun();
    printf("in main\n");
    return 0;
}

接收子进程退出的状态

#include<stdio.h>
#include<stdlib.h>
#include <sys/types.h>
#include <unistd.h>
#include <sys/wait.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("child\n");
        exit(0);    // 代表正常退出,返回0
    }
    else //父进程
    {
        int s;
        printf("parent\n");
        wait(&s);
        printf("%d\n", s);
    }
    return 0;
}

4、获取进程号

4.1 获取PID

#include <sys/types.h>

#include <unistd.h>

pid_t getpid(void);

功能：获取当前进程的进程号

4.2 获取PPID

#include <sys/types.h>

#include <unistd.h>

pid_t getppid(void);

功能：获取当前进程的父进程号

4.3 举例

#include<stdio.h>
#include <sys/types.h>
#include <unistd.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("child中pid:%d ppid:%d\n", getpid(), getppid());
    else //父进程
        printf("parent中子进程pid:%d pid:%d\n", pid, getpid());
    while (1);
    return 0;
}