C++学习：第六章Linux高级编程 - （五）目录、进程、system、popen2、exec、父子进程、fork

最新推荐文章于 2022-09-29 14:15:29 发布
最新推荐文章于 2022-09-29 14:15:29 发布
阅读量406 收藏 1
点赞数
分类专栏： C++
共享知识，欢迎转载
本文链接：https://blog.csdn.net/kakiebu/article/details/108672021
版权

一、IO与文件目录管理

     1. pread = lseek + read

          pread读取以后不改变读写位置

     2. mmap映射：

          /proc/${pid}/mem 无法映射

     3. IO的有效用户与实际用户

          默认情况：实际用户与有效用户一直。        

          实际用户：执行用户

          有效用户：权限用户

          uid_t getuid()

          uid_t geteuid()

     4. 目录相关函数

          chdir      切换目录

          mkdir     创建目录

          rmdir     删除目录

          unlink    删除文件

          umask    设置文件权限屏蔽位

          stat 文件目录状态

     5. 目录的遍历

          opendir  系列函数

          readdir  

          closedir 

          seekdir  

          dirfd 

          int scandir(const char*dirname,      //目录名

          struct dirent***namelist,  //返回目录列表

          int (*)(struct dirent*), //回调函数，过滤目录；NULL：不过滤

          int (*)(struct dirent*,struct dirent*)       //排序返回目录；NULL：不排序

          );

          返回：

          >=0 目录个数

          =-1  目录查找失败

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

main()
{
    DIR *d;
    struct dirent *de;

    //打开目录
    d=opendir("/home");
    if(d==NULL)
    {
        printf("opendir:%m\n");
        exit(-1);
    }

    //循环读取目录
    while(de=readdir(d))
    {
        printf("%s,\t%d\n",de->d_name,de->d_type);
    }

    //关闭目录
    closedir(d);
}

.二、 进程

     1. 什么是进程

          执行的程序：代码->资源->CPU

          进程有很多数据维护：进程状态/进程的属性

          所有进程属性采用的结构体维护->树性数据结构

          ps 察看进程常见属性

          top 察看系统进程执行状况

          pstree(ptree)

          kill 向进程发送信号

               kill  -s 信号 进程id

               kill -l 显示进程能接受的所有信号

          知道进程有很多属性：ps可以察看的属性

          进程状态：

               D    不可中断的睡眠状态

               R    进程运行状态

               S     可中断的睡眠状态

               T     被停止状态

               W  

               X    进程死亡状态

               Z     进程僵尸状态

               <     高优先级

               N    低优先级

               l      多线程

               s      会话头

               +     前台进程

     2. 创建进程

          2.1 代码？加载到内存？分配CPU时间片?

               代码由独立的程序存在.

          2.2 进程有关的创建函数

               int system(const char*filename);

               建立独立进程，拥有独立的代码空间，内存空间

               等待新的进程执行完毕，system才返回.(阻塞)

          案例：

               使用system调用一个程序。

               观察进程ID。

               观察阻塞。

                    新的返回值与system返回值有关系。

                    任何进程的返回值：不要超过255。一个字节。

                    system的返回值中8-15位存放返回码，用WEXITSTATUES

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

main()
{
   int r;
   printf("%d\n",getpid());
   r=system("ls -l ");
   //printf("%d\n",r>>8&255);
   printf("%d\n",WEXITSTATUS(r));
   system("clear");
}

     练习：

          使用system调用"ls -l"。"ls -l home"

          子进程：被创建进程。

          父进程：相对被创建者的进程。

               popen：创建子进程

               在父子进程之间建立一个管道

     案例：

          使用popen调用ls -l，并且建立一个管道读取输出

               exec系列函数:

               execl      execlp

                    替换当前进程的代码空间中的代码数据

                    函数本身不创建新的进程。

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

                    第一个参数：替换的程序,

                    第二个参数....：命令行

                         命令行格式：命令名  选项参数

                        命令行结尾必须空字符串结尾

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

int main()
{
    //printf("main:%d\n",getpid();
    int r = execl(“test”, “mytest”, “-l”, NULL);
    //int r=execlp("ls","ls","-l",NULL);//以NULL结尾
    printf("结束 %d \n",r);
    return 0;
}

    代码空间的代码被替换，因此打印不会输出

    案例：

        使用exec执行一个程序。

        体会：

            *是否创建新的进程？没有

            *体会execl的参数的命令行的格式

            *体会execl与execlp的区别(execl只当前路径)

                 execlp 使用系统的搜索路径

            *体会execl替换当前进程的代码

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

int main()
{
    //printf("main:%d\n",getpid();
    int r = execl(“ls”, “ls”, “-l”, NULL);//报错
    int r = execl(“test”, “mytest”, “-l”, NULL);//正确

    //int r=execlp("ls","ls","-l",NULL);//正确
    printf("结束 %d \n",r);
    return 0;
}

   fork

        pid_t  fork();

        //1.创建进程

        //2.新进程的代码是什么:克隆父进程的代码，而且克隆了执行的位置.

        //3.在子进程不调用fork所以返回值=0;

        //4.父子进程同时执行.

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

int main()
{
    int pid;

    printf("创建进程前!\n");
    pid=fork();

    if(pid==0)
    {
        while(1)
        {
            printf("子进程\n");
            sleep(1);
        }
    }
    else
    {
        while(1)
        {
            printf("父进程\n");
            sleep(1);
        }
    }
    return 0;
}

     3. 应用进程

          使用fork创建新的进程有什么应用价值呢?

          使用fork实现多任务.(Unix系统本身是不支持线程)

          3.1 进程

          3.2 线程

          3.3 信号

          3.4 异步

          3.5 进程池与线程池

     案例:

          使用进程创建实现多任务

     1. UI

     2. 建立多任务框架

     3. 分别处理不同的任务

#include <curses.h>
#include <unistd.h>
#include <time.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <math.h>

WINDOW *wtime,*wnumb;

main()
{
    initscr();
    wtime=derwin(stdscr,3,10,0,(COLS-10));
    wnumb=derwin(stdscr,3,11,(LINES-3)/2,(COLS-11)/2);
    box(wtime,0,0);
    box(wnumb,0,0);

    refresh();
    wrefresh(wtime);
    wrefresh(wnumb);

    if(fork())
    {
        //show time
        time_t tt;
        struct tm *t;

        while(1)
        {
            time(&tt);
            t=localtime(&tt);
            mvwprintw(wtime,1,1,"%02d:%02d:%02d",
                t->tm_hour,t->tm_min,t->tm_sec);
            refresh();
            wrefresh(wtime);
            wrefresh(wnumb);
            sleep(1);
        }
    }
    else
    {
        //show number
        int num=0;
        int i;
        while(1)
        {
            num=0;
            for(i=0;i<7;i++)
            {
                num=num*10+rand()%10;
            }
            mvwprintw(wnumb,1,2,"%07d",num);
            refresh();
            wrefresh(wtime);
            wrefresh(wnumb);
            usleep(10000);
        }
    }
    endwin();
}

运行结果

 

     4. 理解进程

          4.1 父子进程的关系

               独立的两个进程

               互为父子关系

          4.2 问题:

               1. 父进程先结束?

                    所有的进程就会挂在根进程上

                    子进程就依托根进程init：孤儿进程

                    孤儿进程没有任何危害.

               2. 子进程先结束?

                    子进程会成为僵死进程.

                   僵死进程不占用内存，CPU。但在进程任务管理树占用一个节点。

                   僵死进程造成进程名额资源浪费.

                   所以处理僵死进程.

              3. 僵死进程使用wait()函数回收

                   int status;

                   wait(&status);

                   printf("回收中.....\n");

                   sleep(5);       

                   printf("回收完毕:%d!\n",WEXITSTATUS(status));

              4. 父进程怎么知道子进程退出?

                   子进程结束通常会向父进程发送一个信号，SIGCHLD

              5. 父进程处理子进程退出信号

                   signal(int sig,void(*fun)(int));

                   向系统注册：只要sig信号发生，系统停止进程，并调用函数fun当函数执行完毕，继续原来进程

                   5.1 实现处理函数

                   5.2 使用signal邦定信号与函数

                        僵死进程回收案例：

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

void deal(int s)
{
int status;
wait(&status);
printf("回收中.....\n");
sleep(5); 
printf("回收完毕:%d!\n",WEXITSTATUS(status)); 
}

main()
{
    if(fork()==0)
    {
        //parent
        printf("child!\n");
        sleep(20);
        printf("退出!\n");
        exit(88);
    }
    else
    {
        //child
        signal(17,deal);//17是个状态码
        while(1)
        {
            printf("parent!\n"); 
            sleep(1);
        }
        sleep(20000);
        printf("parent!\n");
    }
}

     6. 父子进程的资源访问

          6.1 内存资源

          6.2 文件资源

     案例：

          子进程克隆整个内存区域，但内存区域指向不同的物理空间。尽管克隆，但内存独立，不能相互访问。多进程实现多任务，进程之间的数据交换是大问题。(IPC)Inter-Process Commucation

          说明：子进程克隆了父进程的全局区、局部区域内存。

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

main()
{
    int a=40;
    if(fork())
    {
        printf("parent:%d\n",a);
    }
    else
    {
        printf("child:%d\n",a);
    }
}

     都可以输出。

     说明：子进程的虚拟地址重新映射的（彼此是独立的）。

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

main()
{
    int a=40;       //栈
    if(fork())
    {
        printf("parent:%d\n",a);
        a = 90;
    }
    else
    {
        printf("child:%d\n",a);
        sleep(3);
        printf("child:%d\n",a);
    }
}

不能输出90

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

main()
{
    int *a=malloc(4);//堆
    *a=40;

    if(fork())
    {
        printf("parent:%d\n",*a);
        *a=90;
    }
    else
    {
        printf("child:%d\n",*a);
        sleep(3);
        printf("child:%d\n",*a);
    }
}

     不能输出90

     映射内存:

          MAP_SHARED：映射到同一物理内存

          MAP_PRIVATE：映射到不同的物理内存.

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

main()
{
    /*
        int *a=mmap(0,4,PROT_READ|PROT_WRITE,
        MAP_ANONYMOUS|MAP_PRIVATE,0,0);
    */

    int *a=sbrk(4);
    *a=40; 

    if(fork())
    {
        printf("parent:%d\n",*a);
        *a=90;
    }
    else
    {
        printf("child:%d\n",*a);
        sleep(3);
        printf("child:%d\n",*a); 
    } 
}

     案例：

     两个进程之间，文件描述符号指向的是同一个文件内核对象。

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/wait.h>
#include <signal.h>
#include <sys/mman.h>
#include <fcntl.h>

main()
{
    int fd=open("test.txt",O_RDWR);
    
    if(fork())
    {
        char buf[1024] = {0};
        read(fd, buf, 1024);
        printf("parent %s \n", buf);
        close(fd);
        while(1);
    }
    else
    {
        char buf[1024] = {0};
        read(fd, buf, 1024);
        printf("child %s \n", buf);
        while(1);
        lose(fd);
    }
    //close(fd);//注意：这里是关闭两次，或者是两个进程中分别关闭
}

     不能同时读取文件，因为第二个进程在读取文件时受到第一个文件读取的指针偏移影响。可以   seek(fd, 0, SET); 设置指针偏移位置

     结论：

          进程的数据交换，基于两种方式：

          内存：有序内存/无序内存：mmap可以映射共享内存

          文件：有序文件/无序文件：普通文件可以完成数据共享交换

          基于内核对象：文件、内存、队列

     回顾：

          1. 目录遍历

          2. 进程创建system popen exec fork

          3. 僵死进程出现的条件以及回收

          4. 利用多进程实现简单的多任务

          5. 理解进程的克隆.

     作业：

          1. 使用两个进程,查找素数:(多任务)

               A进程查找1-5000

               B进程查找5001-10000

        把素数写入文件.

               写一个多任务:(两个进程数据共享)

               A 进程查找素数,放入mmap分配的空间

               B 进程把mmap的数据取出来,判定两个数据是否相邻.

               相邻就打印这两个素数

        思考：

使用opendir/readir遍历指定目录下的所有*.c文件.scandir 

     明天:

          进程的基本控制

          进程的高级控制-信号

Thomas会写字
关注
专栏目录
【并发编程二十三】linux系统，c++启动进程、杀进程、查询进程id
junxuezheng的博客
07-24 1078
简介：在Linux系统中，使用C++编写程序可以通过多种方式控制进程，如启动程序、杀死进程和查询进程ID。本教程将详细介绍在Linux系统中使用C++的system函数、popen函数、fork函数以及相关命令的区别和用法。
C++笔记之linux下运行系统shell命令(popen方法)函数封装
小勇博客
05-31 1028
C++笔记之linux下运行系统shell命令(popen方法)函数封装 代码 #include <iostream> #include <stdio.h> #include <string.h> int cmd_popen(std::string cmd) { char outBuffer[1024]; memset(outBuffer, '\0', sizeof(outBuffer)); const char *cmd_str = cmd.
linux高级编程day05 笔记
weixin_33946020的博客
08-22 118
一.IO与文件目录管理1.pread=lseek+readpread读取以后不改变读写位置2.mmap映射：/proc/${pid}/mem 无法映射3.IO的有效用户与实际用户默认情况：实际用户与有效用户一致。实际用户：执行用户有效用户：权限用户uid_t getuid()uid_t geteuid() View Code #incl...
父进程与子进程
qq_15099443的博客
12-06 7056
进程的定义： 进程的经典定义就是一个执行中程序的实例，是计算机科学中最深刻、最成功的概念之一。 假象： 在现代系统上运行一个程序时，我们会得到一个假象，就好像我们的程序是系统当中运行的唯一程序一样。我们的程序好像独占的使用处理器和内存。处理器就好像是无间断地一条接一条的执行我们程序中的指令。最后，我们程序中的数据和代码好像是系统中内存的唯一对象。然而，这些都是假象，都是进程带给我们的。 真相： 关...
Linux C/C++ 进程管理
TYtrack的博客
04-12 579
在UNIX/LINUX系统中，用户创建一个新进程的唯一方法就是调用系统调用fork()，调用该函数的进程被称作为父进程，而新创建的进程被称作为子进程，调用语法为下： x_val = fork() 调用这个函数之后，之后的代码被子进程和父进程各执行一次，因为子进程拷贝了父进程的上下文逻辑副本，唯一的区别是x_val不一样，子的x_val是0，父的x_val是子进程的进程号，详细操作如下： 为新的进程分配一个新的PCB 结构 为子进程赋一个唯一的进程标识符PID 做一个父进程的上下文逻辑副本，（代码段
Linux c/c++之进程基础
ShiXiAoLaNga的博客
03-03 594
进程的定义 运行中的程序(必须是运行之中的程序) 不在运行之中的程序只能被称为可执行的程序文件 进程是操作系统资源调度的基本单位 线程是操作系统调度的基本单位 内存的最小管理单位 比特位(bit) 内存的最小管理单位 字节(byte) 资源: 内存 fd(文件描述符) cpu时间片 等等... 进程的组成 数据: 全局变量 静态变量(已初始化,未初始化) 只读变量 代码: 进程的源代码 堆栈: 普通变量...
fork、exec系列与system、popen区别.rar_UNIX popen_linux system pop_pop
09-21
在UNIX和Linux操作系统中，进程创建和控制是通过一系列系统调用来实现的，其中最常见的是`fork`、`exec`系列以及`system`和`popen`函数。这些调用各自有不同的特性和用途，理解它们的区别对于进行系统级编程至关重要...
Linux系统编程-进程创建(fork)、外部程序调用(exec)
01-28 2559
在linux中fork函数是非常重要的函数，它可以从已存在进程中创建一个新进程。新进程为子进程，而原进程为父进程。
C语言的多进程fork()、函数exec*()、system()与popen()函数
DRAXY的博客
05-07 1804
C语言的多进程fork()、函数exec*()、system()与popen()函数
Linux--exec族函数，system函数，popen函数
qq_46036601的博客
07-19 335
一、exec族函数 exec族函数作用：fork创建新进程后，经常会在新进程中调用exec函数去执行另外一个程序。当进程调用exec函数时，该进程被完全替换成新程序。exec函数并不创建新进程，前后进程的id并不改变。 功能：在调用进程内部执行一个可执行文件。可执行文件既可以是二进制文件，也可以是Linux下可执行的脚本文件。 返回值：exec函数族的函数执行成后不会返回，调用失败时，会设置error返回-1，然后从原程序的调用点接着往下执行。 execl：参数最后必须以NULL结尾 #incl
LINUX进程间通信：PIPE与FIFO - 山 人 - 博客园1
08-04
### LINUX进程间通信：PIPE与FIFO #### 概述 在Linux系统中，进程间的通信（IPC）是一项重要的功能，使得不同的进程能够共享或交换数据。本文将深入探讨两种基本且广泛使用的IPC机制——**PIPE**（管道）与**FIFO*...
popen 函数
weixin_34006468的博客
04-12 198
函数原型：#include<stdio.h>FILE* popen(const char* command, const char* type);void pclose(FILE* stream);man文本英语描述：DESCRIPTION： The popen() function opens a process by cre...
Linux & OS——进程/线程管理（二）：线程-C++11线程库
weixin_42923076的博客
04-24 81
Linux & OS——进程/线程管理（二）：线程-C++11线程库 线程类与内存栅栏
Linux C C++：进程
weixin_49777720的博客
03-16 1594
文章目录进程和程序进程号和父进程号返回该进程进程号：getpid()函数返回该进程的父进程号：getppid()函数 本章研究进程，重点关注进程的虚拟内存布局及内容 进程和程序 程序： 二进制格式标志 机器语言指令 程序入口地址 数据 符号表及重定位表 共享库和动态链接信息 其他信息 进程： 进程由用户内存空间和一系列内核数据结构组成 用户内存空间：程序代码及代码所使用的变量 内核数据结构：进程标识号、虚拟内存表、打开文件描述符表、信号传递及处理的有关信息、进程资源使用及限制、当前工作目录和大量的其他信
操作系统 进程控制和通信 C++简单实现
qq_52788258的博客
09-29 691
进程互斥的方法，进程通信的基本原理。 用vi编写C语言程序，创建子进程并实现父子进程间的通信，使用gcc编译并运行。 系统平台 Linux
C＋＋中使用popen运行linux系统命令并获取输
weixin_42428854的博客
09-26 1591
system()函数只能运行命令，不能获取输出 #include <stdio.h> #include <string.h> #include <iostream> int main(){ char outBuffer[4096]; // 保存运行后输出的结果 char *CmdStr = "md5sum te.cpp"; // 准备运行的命令 FILE * pipeline = popen(CmdStr,"r"); // 建立流管道
操作系统课设之Linux 进程管理
RongLin02的博客
06-28 4296
操作系统课程设计 Linux创建进程 Linux进程管理
Linux编程使用popen函数
Learning
05-07 687
在Linux环境下，在编写程序时，使用popen()函数执行系统中的命令，并将获取的结果放在程序中使用。 不要忘记最后执行pclose()。 函数的原型在文件/usr/include/stdio.h中 /** * Linux */ #include <stdio.h> // popen, fgets, pclose #include <vector> #include...
linux c++ popen 使用 多个命令,c++ - popen（）如何工作以及如何在Linux上将其实现为C ++代码？ - 堆栈内存溢出...
weixin_32559261的博客
05-02 1696
如何使用popen()将stdout从Linux的子程序中捕获到主C ++程序您熟悉UNIX哲学吗？ 您可能会阅读Wikipedia文章“ UNIX Philosophy”的开头。 这是一个片段：UNIX哲学由Doug McIlroy [1]在1978年的《贝尔系统技术杂志》上发表：[2]1)让每个程序做好一件事情。 要完成一项新工作，请重新构建而不是通过添加新的“功能”使旧程序复杂化。2)...
探索fork、exec系列与system、popen在UNIX/Linux中的差异
本文档主要探讨了UNIX/Linux系统中fork和exec系列调用的区别，以及它们与system、popen函数在进程创建和程序执行方面的不同。fork用于创建新的进程，exec用于执行新的程序，而system和popen则是对这两个操作的高级...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值