day06（IO进程）进程 process

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

面试题：

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

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

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

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

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

原因：抢占式调度相对于轮询调度来说实现相对复杂，需要记录和管理任务的优先级、状态等信息。

2.会导致进程从执行态变为就绪态的事件是（）。(大明科技)

A. 执行P（wait）操作

B. 申请内存失败

C. 启动I/O设备

D. 被高优先级进程抢占

3. 分配到必要的资源并获得处理机时的进程状态是（）。(大明科技)

A. 就绪状态

B. 执行状态

C. 阻塞状态

二. 进程函数接口

1. 创建进程 fork()

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[])
{
    pid_t pid;
    pid = fork();  //创建了一个子进程
    if(pid < 0)
    {
        perror("fork err");
        return -1;
    }
    else if(pid == 0)
    {
        printf("i am child process\n");
        while(1);   //为了让子进程不要结束
    }
    else
    {
        printf("i am parent process\n");
        while(1);   //为了让父进程不要结束
    }

    return 0;
}

特点：

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

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

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

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

2. 回收资源

wait

pid_t wait(int *status);
功能：回收子进程资源(阻塞)
参数：status：子进程退出状态，不接受子进程状态设为NULL
返回值：成功：回收的子进程的进程号
              失败：-1

waitpid

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 <stdio.h>
#include <sys/wait.h>

int main(int argc, char const *argv[])
{
    pid_t pid;
    pid = fork(); //创建了一个子进程
    if (pid < 0)
    {
        perror("fork err");
        return -1;
    }
    else if (pid == 0)
    {
        printf("i am child process\n");
        sleep(3); //子进程睡眠3秒之后再结束
    }
    else
    {
        //wait(NULL); //给任意结束的子进程回收资源，如果没有子进程结束就一直阻塞等待。
        //waitpid(-1, NULL, 0);  //0: 代表阻塞，此时和wait(NULL);效果一样
        //waitpid(-1, NULL, WNOHANG); //WNOHANG: 代表非阻塞， 此时有可能回收不到子进程资源从而产生僵尸，所以可以通过循环调用解决。
        while (1)  //循环调用，直到回收到子进程资源以后再退出
        {
            if (waitpid(-1, NULL, WNOHANG) > 0)
                break;
        }

        printf("i am parent process\n");
        while (1)
            ;
    }

    return 0;
}

3. 结束进程

exit

void exit(int status);
功能：结束进程，刷新缓存

_exit

void _exit ( int status );
功能：结束进程，不刷新缓存

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

通常0表示正常结束；

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

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

int main(int argc, char const *argv[])
{
    printf("hello");
   // exit(0);  //结束进程，刷新缓存
   _exit(0);   //结束进程，不刷新缓存
    while (1);

    return 0;
}

思考: exit和return的区别?

exit：不管在子函数还是主函数，都可以结束进程
return：当子函数中有return时返回到函数调用位置，并不结束进程

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

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

int fun()
{
    printf("in fun\n");
    //exit(0);   //结束当前进程
    return 0;   //结束当前函数
}

int main(int argc, char const *argv[])
{
    fun();
    printf("in main\n");
    return 0;
}

4. 获取进程号 getpid getppid

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

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

例如：父子进程中分别打印这两个进程的进程号

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

int main(int argc, char const *argv[])
{
    pid_t pid;
    pid = fork(); //创建了一个子进程
    if (pid < 0)
    {
        perror("fork err");
        return -1;
    }
    else if (pid == 0)
    {
        printf("i am child process:%d %d\n", getpid(), getppid());
    }
    else
    {
        printf("i am parent process: %d %d\n", pid, getpid());
    }
    while (1);  //让父子进程都不要结束

    return 0;
}

三.exec函数族(了解)

在一个进程中执行另一个程序:

system("clear");

system("ls -l");

system不会代替原来进程，而exec函数族会代替原来进程。

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

int main(int argc, char const *argv[])
{
    printf("hello\n");
    //system("ls -l");   //原来进程不会被替换，执行完ls -l启动的进程之后继续执行原先进程
    execl("/bin/ls","ls","-l",NULL);  //原先进程被ls -l启动的进程替换了，所以后面打印语句不执行了
    printf("world\n");

    return 0;
}

原型：

#include <unistd.h>

int execl(const char *path, const char *arg, ...);

int execlp(const char *file, const char *arg, ...);

int execle(const char *path, const char *arg,..., char * const envp[]);

int execv(const char *path, char *const argv[]);

int execvp(const char *file, char *const argv[]);

int execvpe(const char *file, char *const argv[],char *const envp[]);

四.守护进程

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

1. 守护进程的特点

守护进程是后台进程；

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

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

2. 创建步骤

(1) 创建子进程，父进程退出。

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

(2) 在子进程中创建新会话

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

(3) 改变进程运行路径为根目录

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

函数说明：chdir() 将进程当前的工作目录改变成以参数路径所指的目录

(4) 重设文件权限掩码

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

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

(5) 关闭文件描述符

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

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

#include<stdio.h>
#include<stdlib.h>
#include<unistd.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;
}

练习：创建一个守护进程，循环间隔1s向文件中写入一串字符“hello”

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

int main(int argc, char const *argv[])
{
    pid_t pid;
    pid = fork();
    if (pid < 0)
    {
        perror("fork err");
        return -1;
    }
    else if (pid == 0)
    {
        int fd = open("log.txt", O_RDWR | O_CREAT | O_TRUNC, 0777);
        if (fd < 0)
        {
            perror("open err");
            return -1;
        }
        setsid();
        chdir("/");
        umask(0);
        for (int i = 0; i < 3; i++)
            close(i);
        while (1)
        {
            write(fd, "hello", 5);
            sleep(1);
        }
    }
    else
    {
        exit(0);
    }

    return 0;
}

总结守护进程：

守护进程是一个生存周期较长的进程，通常独立于控制终端并且周期性的执行某种任务或者等待处理某些待发生的事件
大多数服务都是通过守护进程实现的
关闭终端，相应的进程都会被关闭，而守护进程却能够突破这种限制

标签：const,process,pid,day06,char,int,进程,include
From： https://blog.csdn.net/QR70892/article/details/141651928

day06（IO进程）进程 process

一.什么是进程

1. 概念

2. 特点

3. 进程段

4. 进程分类

5. 进程状态

6. 进程状态切换图

7. 进程相关命令

补充：优先级调度（笔试可能遇见）