LinuxC编程——进程

目录

  • 一、概念
    • 1.1 程序
    • 1.2 进程
  • 二、特点⭐⭐⭐
  • 三、进程段
  • 四、进程分类
  • 五、进程状态
  • 六、进程状态转换图
  • 七、函数接口
    • 1. 创建子进程
    • 2. 回收进程资源
    • 3. 退出进程
    • 4. 获取进程号
  • 八、守护进程

一、概念

进程和程序是密不可分的两组概念,相对比,便于理解。

1.1 程序

简单来说,程序即编译好的可执行文件

展开来说:

  • 编译好的可执行文件
  • 存放在磁盘上的指令和数据的有序集合(文件)
  • 静态的,没有执行的概念

1.2 进程

程序一次执行过程,是动态的,包括创建、调度、执行以及消亡,它是一个独立的可调度的任务
展开来说:

  • 进程是程序的一次执行过程。
  • 进程是动态的,包含创建、调度、执行、消亡。
  • 进程是执行一个程序分配资源的总称。
  • 独立的可调度的任务

二、特点⭐⭐⭐

  1. 系统会为每一个进程分配0-4g的虚拟空间,其中0-3g(用户空间)是每个进程所独有的,3g-4g(内核空间)是所有进程共有的。
  2. CPU调度进程时会给进程分配时间片(几毫秒 ~ 十几毫秒),当时间片用完后,cpu再进行其他进程的调度,实现进程的轮转,从而实现多任务的操作。

三、进程段

Linux中的进程包含三个段:

  1. “数据段”存放的是全局变量、常数以及动态数据分配的数据空间(如malloc函数取得的空间)等。
  2. “正文段”存放的是程序中的代码
  3. “堆栈段”存放的是函数的返回地址、函数的参数以及程序中的局部变量

四、进程分类

  1. 交互进程:该类进程是由shell控制和运行的。交互进程既可以在前台运行,也可以在后台运行。该类进程经常与用户进行交互,需要等待用户的输入,当接收到用户的输入后,该类进程会立刻响应,典型的交互式进程有:shell命令进程、文本编辑器等
  2. 批处理进程:该类进程不属于某个终端,它被提交到一个队列中以便顺序执行。
  3. 守护进程:该类进程在后台运行。它一般在Linux启动时开始执行,系统关闭时才结束。

五、进程状态

  1. 运行态(TASK_RUNNING)R:指正在被CPU运行或者就绪的状态。这样的进程被成为runnning进程。
  2. 睡眠态(等待态)
  • 可中断睡眠态(TASK_INTERRUPTIBLE)S:处于等待状态中的进程,一旦被该进程等待的资源被释放,那么该进程就会进入运行状态。
  • 不可中断睡眠态(TASK_UNINTERRUPTIBLE)D:该状态的进程只能用wake_up()函数唤醒。
  1. 暂停态(TASK_STOPPED)T:当进程收到信号SIGSTOP、SIGTSTP、SIGTTIN或SIGTTOU时就会进入暂停状态。可向其发送SIGCONT信号让进程转换到可运行状态。
  2. 死亡态X:进程结束
  3. 僵尸态(TASK_ZOMBIE)Z:当进程已经终止运行,但还占用系统资源,要避免僵尸态的产生(例如:在父子进程中,子进程比父进程先结束,而父进程没有对子进程及时回收,释放子进程占用的资源,此时子进程将变成一个僵尸进程)。

六、进程状态转换图

进程创建后,进程进入就绪态,当CPU调度到此进程时进入运行态,当时间片用完时,此进程会进入就绪态,如果此进程正在执行一些IO操作(阻塞操作)会进入阻塞态,完成IO操作(阻塞结束)后又可进入就绪态,等待CPU的调度,当进程运行结束即进入结束态。
LinuxC编程——进程_第1张图片

七、函数接口

1. 创建子进程

pid_t fork(void);

  • 功能:创建子进程

  • 参数:无

  • 返回值

    • 成功:在父进程中:返回子进程的进程号 >0;在子进程中:返回值为0
    • 失败:-1并设置errno
  • 特点⭐⭐⭐

    1. 子进程几乎拷贝了父进程的全部内容,包括:代码、数据、系统数据段中的pc值、栈中的数据、父进程中打开的文件等;但它们的PID、PPID是不同的。
    2. 父子进程有独立的地址空间,互不影响;当在相应的进程中改变全局变量、静态变量,都互不影响。
    3. 若父进程先结束,子进程成为孤儿进程,被init进程收养,子进程变成后台进程。
    4. 若子进程先结束,父进程如果没有及时回收,子进程变成僵尸进程(要避免僵尸进程产生)
  • 拓展:

    1. fork之前的代码被复制,但是不会重新执行一遍;fork之后的代码被复制,并且再被执行一遍。
    2. fork之后两个进程相互独立,子进程拷贝了父进程的所有代码,但内存空间独立
    3. fork之前打开文件,fork之后拿到的是同一个文件描述符,操作的是同一个文件指针。(而不同的进程打开相同的文件,操作的是不同的文件指针)
    4. fork函数创建父子进程后各自执行顺序不一定(vfork:先执行完子进程,再执行父进程)
  • 例子:

#include 
#include 
// 若父进程先结束,子进程将变成孤儿进程 且被init进程收养,变成孤儿进程
// 若子进程先结束,父进程如果没与及时回收,子进程将变成僵尸进程
int main(int argc, char const *argv[])
{
    int a =0;
    pid_t pid = fork();
    if(pid<0){
        perror("fork err");
        return -1;
    }
    else if(pid == 0){ // 运行子进程
        printf("child a:%d\n",a);
        while(1);
    }
    else{  // 运行父进程
        a=3;
        printf("parent a:%d\n",a);
        //while(1);
    }
    return 0;
}

2. 回收进程资源

  • wait:pid_t wait(int *status);
    • 功能:回收子进程资源(阻塞)
    • 参数
      • status:子进程退出状态,不接受子进程状态设为NULL
    • 返回值
      • 成功:回收的子进程的进程号
      • 失败:-1
  • waitpid:pid_t waitpid(pid_t pid, int *status, int options);
    • 功能:回收子进程资源
    • 参数:
      • pid:
        LinuxC编程——进程_第2张图片
      • status:子进程退出状态
      • options:
        • 0:阻塞
        • WNOHANG:非阻塞
    • 返回值
      • 正常:结束的子进程的进程号
      • 当使用选项WNOHANG且没有子进程结束时:0
      • 出错:-1
#include 
#include 
#include 
#include 
int main(int argc, char const *argv[])
{
    int a = 0;
    pid_t pid = fork();
    if(pid<0){
        perror("fork err");
        return -1;
    }
    else if(pid == 0){
        printf("in child a=%d\n",a);
        // while(1);
        sleep(1);
    }
    else{
        a = 3;
        // wait(NULL); //阻塞回收所有子进程
        // waitpid(-1,NULL,0); //阻塞回收所有子进程
        waitpid(pid,NULL,0); // 阻塞回收pid进程
        // waitpid(pid,NULL,WNOHANG); //不阻塞回收进程号为pid的进程
        printf("in parent a = %d\n",a);
        // while(1);
        wait(NULL);
        printf("parent end...\n");
    }
    return 0;
}

3. 退出进程

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

注:exit与return的区别⭐⭐

  • exit:函数,不管在子函数还是主函数,都可以结束进程(进程的退出)
  • return:关键字,当子函数中有return时返回到函数调用位置,并不结束进程(函数的退出)
    例子:
#include 
#include 
#include 
#include 
#include 

void fun(int a, int b)
{
    printf("a+b=%d",a+b);
    // exit(0); // 结束进程,刷新缓存
    _exit(0); // 结束进程,不刷新缓存
    return;
}

int main(int argc, char const *argv[])
{
    pid_t pid = fork();
    if(pid<0){
        perror("fork err");
        return -1;
    }
    else if(pid == 0){
        printf("in child\n");
        fun(3,4);
        sleep(1);
    }
    else{
        printf("in parent\n");
        // while(1);
        wait(NULL);
        printf("parent end...\n");
    }
    return 0;
}

运行结果:
exit:会刷新缓存
LinuxC编程——进程_第3张图片
_exit:不会刷新缓存
LinuxC编程——进程_第4张图片

4. 获取进程号

  • getpid:pid_t getpid(void);
    • 功能:获取当前进程的进程号
  • getppid:pid_t getppid(void);
    • 功能:获取当前进程的父进程号
      例:
#include 
#include 
#include 
#include 
#include 
#include 
int main(int argc, char const *argv[])
{
    pid_t pid = fork();
    if(pid<0)
    {
        perror("fork err");
        return -1;
    }
    else if(pid == 0)
    {
        printf("childpid:%d ppid:%d pid:%d\n",getpid(),getppid(),pid);
        exit(0);
    }
    else
    {
        printf("parentpid:%d ppid:%d pid:%d\n",getpid(),getppid(),pid);
        wait(NULL);
    }
    return 0;
}

运行:
在这里插入图片描述

练习:通过父子进程完成对文件的拷贝(cp),父进程从文件开始到文件的一半开始拷贝,子进程从文件的一半到文件末尾。要求:文件IO cp src dest

  • 方法一
    这里先执行子进程来进行源文件后半部分的复制,然后执行父进程来进行源文件前半部分的复制
    LinuxC编程——进程_第5张图片
    方法二:
    这里先执行父进程来进行源文件前半部分的复制,后执行子进程来进行源文件后半部分的复制
//通过父子进程完成对文件的拷贝(cp),父进程从文件开始到文件
//的一半开始拷贝,子进程从文件的一半到文件末尾。要求:文件IO cp src dest
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
int main(int argc, char const *argv[])
{
    if (argc != 3)
    {
        printf("Please input:%s  \n", argv[0]);
        return -1;
    }
    int src = open(argv[1], O_RDONLY);
    if (src < 0)
    {
        perror("srcfile open err");
        return -1;
    }
    int dest = open(argv[2], O_WRONLY | O_TRUNC | O_CREAT, 0666);
    if (dest < 0)
    {
        perror("destfile open err");
        return -1;
    }
    off_t half = lseek(src, 0, SEEK_END) / 2; // 文件长度的一半
    int flag = 0;                             // 控制下面父子进程执行顺序,让父进程先执行
    ssize_t s;
    char buf[32] = {0};

    pid_t pid = fork();
    if (pid < 0)
    {
        perror("fork err");
        return -1;
    }
    else if (pid == 0) // 子进程 复制源文件后半部分
    {
        while (flag == 1) // 父进程已复制完毕,子进程可以执行
        {
            lseek(src, half, SEEK_SET);
            lseek(dest, half, SEEK_SET);
            while ((s = read(src, buf, 32)) != 0)
                write(dest, buf, s);
        }
    }
    else // 父进程 复制源文件前半部分(先执行)
    {
        lseek(src, 0, SEEK_SET);
        lseek(dest, 0, SEEK_SET);
        int n = half;
        if (n < 32)
        {
            read(src, buf, n);
            write(dest, buf, n);
            flag = 1;
            wait(NULL);
        }
        else
        {
            while ((s = read(src, buf, 32)) != 0)
            {
                write(dest, buf, s);
                n = n - s;
                if (n < 32)
                {
                    read(src, buf, n);
                    write(dest, buf, n);
                    flag = 1;
                    wait(NULL);
                }
            }
        }
    }
    close(src);
    close(dest);
    return 0;
}
//通过父子进程完成对文件的拷贝(cp),父进程从文件开始到文件
//的一半开始拷贝,子进程从文件的一半到文件末尾。要求:文件IO cp src dest
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
int main(int argc, char const *argv[])
{
    if (argc != 3)
    {
        printf("Please input:%s  \n", argv[0]);
        return -1;
    }
    int src = open(argv[1], O_RDONLY);
    if (src < 0)
    {
        perror("srcfile open err");
        return -1;
    }
    int dest = open(argv[2], O_WRONLY | O_TRUNC | O_CREAT, 0666);
    if (dest < 0)
    {
        perror("destfile open err");
        return -1;
    }
    off_t half = lseek(src, 0, SEEK_END) / 2; // 文件长度的一半
    int flag = 0;                             // 控制下面父子进程执行顺序,让父进程先执行
    ssize_t s;
    char buf[32] = {0};

    pid_t pid = fork();
    if (pid < 0)
    {
        perror("fork err");
        return -1;
    }
    else if (pid == 0) // 子进程 复制源文件后半部分
    {
        while (flag == 1) // 父进程已复制完毕,子进程可以执行
        {
            lseek(src, half, SEEK_SET);
            lseek(dest, half, SEEK_SET);
            while ((s = read(src, buf, 32)) != 0)
                write(dest, buf, s);
        }
    }
    else // 父进程 复制源文件前半部分(先执行)
    {
        lseek(src, 0, SEEK_SET);
        lseek(dest, 0, SEEK_SET);
        int n = half;
        if (n < 32)
        {
            read(src, buf, n);
            write(dest, buf, n);
            flag = 1;
            wait(NULL);
        }
        else
        {
            while ((s = read(src, buf, 32)) != 0)
            {
                write(dest, buf, s);
                n = n - s;
                if (n < 32)
                {
                    read(src, buf, n);
                    write(dest, buf, n);
                    flag = 1;
                    wait(NULL);
                }
            }
        }
    }
    close(src);
    close(dest);
    return 0;
}

八、守护进程

  1. 特点
    守护进程是后台进程;生命周期比较长,从系统启动时开启,系统关闭时结束;它是脱离控制终端且周期执行的进程。
  2. 实现步骤
    1. 创建子进程,父进程退出
      让子进程成为孤儿进程,成为后台进程。fork
    2. 在子进程中创建新会话
      让子进程成为会话组组长,为了让子进程脱离控制终端。setsid()
    3. 改变运行路径为根目录。chdir
      原因:提高权限,让运行路径不能被删除或卸载。chdir
    4. 重设权限掩码。umask
      目的:增大进程创建文件的权限,提高灵活性。umask
    5. 关闭不必要的文件描述符
      目的:关闭不必要的文件描述符。close
  • 练习:创建一个守护进程,循环间隔1s向文件中写入一串字符“hello”
/*创建守护进程实现往日志文件中循环写入hello,间隔时间为1秒*/
#include 
#include 
#include 
#include 
#include 
#include 

int main(int argc, char const *argv[])
{
    //1.创建父子进程
    pid_t pid = fork();
    if(pid < 0)
    {
        perror("fork err");
        return -1;
    }
    else if(pid == 0) //子进程进入
    {
        setsid(); //2.在子进程中创建新会话,让子进程成为会话组组长
        chdir("/"); //3.改变运行目录为根目录
        umask(0); //4.重设文件掩码
        close(0);//5.关闭文件描述符->0 1 2
        close(1);
        
        int fd = open("/tmp/c.log",O_WRONLY|O_CREAT|O_APPEND,0666);
        if(fd < 0)
        {
            perror("open err");
            return -1;
        }
    }
    else
    {
        exit(0);  //1.父进程退出
    }
    return 0;
}

你可能感兴趣的:(c语言,linux,笔记,嵌入式开发,进程)