进程1——概念，创建，回收

已于 2023-04-29 08:56:18 修改
阅读量50 收藏
点赞数
文章标签： linux
于 2023-04-28 00:15:47 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hhw19970108/article/details/130414123
版权

进程概念

  1. 进程标识符pid
    类型pid_t 一般int_16
    命令 ps 查看进程号
axf 可以看出阶梯状
aux
ax -L 线程相关

进程号是顺次向下使用，与文件描述符不同
#include <sys/types.h>
#include <unistd.h>
pid_t getpid(void); 当前进程id
pid_t getppid(void); parentid

  1. 进程产生fork()
 #include <sys/types.h>
 #include <unistd.h>

 pid_t fork(void);

setjmp的操作和这个很像，一次指向返回两种情况，因此一般该语句后都会跟随一个分支判断
fork出来的与当前进程一模一样，包括执行位置
区别4：

  • pid不同
  • ppid不同
  • 未决信号和文件锁不继承
  • 新进程资源利用量归零
    init进程：是所有进程的祖先进程 pid=1
    在这里插入图片描述
    调度器的调度策略决定哪个进程先运行，没有规定的顺序，一般想强制，可以sleep(但需要考虑移植问题)
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

#include <sys/types.h>

int main()
{
    printf("[%d]:Begin!\n", getpid());
    fflush(NULL);
    pid_t pid = fork();
    if (pid < 0)
    {
        perror("fork()");
        exit(1);
    }
    else if (pid == 0)
    {
        // child
        printf("[%d]:Child is working!\n", getpid());
    }
    else
    {
        // > 0 pid 当前进程id
        printf("[%d]:Parent is working\n", getpid());
    }

    printf("[%d]:End!\n", getpid()); // 父子共有
    return 0;
}


./fork1
./fork1 > tmpfile

./fork1 | wc -l   // 计算输出项的个数

打印出的结果不相同
因为文件是全缓冲，因此在fork前刷新全部的流，fflush(NULL)
终端是设备，行缓冲
关于fork导致资源爆炸问题
在这里插入图片描述
图中展现部分结果，因为子进程执行后没有退出，且子进程是对父进程的复制，使得子进程再次进入外层循环+1，并不断进行fork，树形增长，导致资源爆炸
进程状态：S 睡眠 Z僵尸
案例：

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

#define LEFT 30000000
#define RIGHT 30000200

int main()
{
    int mark;
    pid_t pid;
    for (int i = LEFT; i < RIGHT; i++)
    {
        pid = fork();
        if (pid < 0)
        {
            perror("fork");
            exit(1);
        }
        else if (pid == 0)
        {
            // child
            mark = 1;
            for (int j = 2; j < i / 2; j++)
            {
                if (i % j == 0)
                {
                    mark = 0;
                    break;
                }
            }
            if (mark == 1)
            {
                printf("%d is prime\n", i);
            }
            // sleep(1000); // 让父亲先结束
            exit(0); // 子进程拿到一个i值，操作后，直接退出
        }
    }
    sleep(1000); // 父进程睡眠，子进程退出，但没有父进程为其回收，会变成僵尸
    return 0;
}

僵尸进程一般会存在，但是正常情况是存在一会儿就会收尸了，本身他们并不会占用很多资源，但是会存在占用pid问题，pid一般是16bits有符号数，那进程号就是个有限的资源
因此，收尸的时候需要关注对pid的释放，还有就是子进程回收的时候是什么进程状态 僵尸？睡眠？。。。
在这里插入图片描述
理解vfork和fork的区别：
fork可以理解为深拷贝进程资源
vfork可以理解为浅拷贝进程资源(就是拷贝一个指针,指向的内容还是原来的空间)
但是现在的fork已经加入了写时复制技术
与字面意思相同：如果父进程和子进程都是对一个数据块进行读，那么这两个指针指向同一块物理存储空间，没问题；如果有一个进程对一个数据块进行写，如果子进程，那么该子进程会复制一块该空间，在新空间上进行写操作，即写时复制技术

  1. 进程的消亡及释放资源
    pid_t wait(int *wstatus); // 整型地址，存放收尸状态，返回终止进程id 只有子进程死掉，发送信号，才回收
WIFEXITED(wstatus)  正常终止，返回true
WEXITSTATUS(wstatus) 正常结束的情况下，返回子进程的退出状态码

WIFSIGNALED(wstatus)  由信号终止，返回true
WTERMSIG(wstatus) 由信号终止，返回true，返回导致进程终止的信号码返回
WCOREDUMP(wstatus)  由信号终止，返回true，检测子进程是否产生了core dump文件

WIFSTOPPED(wstatus)
returns  true  if  the  child process was stopped by delivery of a signal; this is possible only if the
call was done using WUNTRACED or when the child is being traced (see ptrace(2)).

WSTOPSIG(wstatus)
returns the number of the signal which caused the child to stop.  This macro should be employed only if WIFSTOPPED returned true.

WIFCONTINUED(wstatus)
(since Linux 2.6.10) returns true if the child process was resumed by delivery of SIGCONT.

pid_t waitpid(pid_t pid, int *wstatus, int options); // 指定回收pid，opt是重点，
WNOHANG–收尸，已经死掉，直接收，正常运行时，不收// 这时是非阻塞的状态，而wait是阻塞的
pid>0，回收指定子进程
pid为0，意味着收同组中的任何一个子进程回来
pid为-1，收任何一个子进程
pid<-1，收|pid|组中的一个子进程

int waitid(idtype_t idtype, id_t id, siginfo_t *infop, int options);

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

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

#define LEFT 30000000
#define RIGHT 30000200
#define N 3  
// 三个进程去计算

int main()
{
    int mark;
    pid_t pid;
    for (int n = 0; n < N; n++)
    {
    // 三个进程交叉分配，存在一个问题，第一个进程拿到的都是3的倍数，所以始终没有计算出素数
        pid = fork();
        if (pid < 0)
        {
            perror("fork");
            // 回收之前fork出去的子进程
            for (int i = 0; i < n; i++)
            {
                wait(NULL);
            }
            exit(1);
        }
        else if (pid == 0)
        {
        	// child
            for (int i = LEFT+n; i <= RIGHT; i+=N)  // 201 
            {
                // child
                mark = 1;
                for (int j = 2; j < i / 2; j++)
                {
                    if (i % j == 0)
                    {
                        mark = 0;
                        break;
                    }
                }
                if (mark == 1)
                {
                    printf("[%d]%d is a prime\n", n, i);
                }
            }
            exit(0); // 子进程拿到一个i值，操作后，直接退出
        }
    }
    
    int st;
    for (int n = 0; n < N; n++)
    {
        wait(&st);
    }
    
    return 0;
}
  1. exec函数族
    函数族是用一个新的进程镜像替换当前的进程镜像
 #include <unistd.h>
extern char **environ;
int execl(const char *pathname, const char *arg,/* (char  *) NULL */);  // 定参 路径，参数+NULL
int execlp(const char *file, const char *arg,/* (char  *) NULL */); // 定参 文件名，参数+NULL
int execle(const char *pathname, const char *arg,/*, (char *) NULL, char *const envp[] */); // 定参 路径，参数+NULL，环境变量

// 变参
int execv(const char *pathname, char *const argv[]); // 路径
int execvp(const char *file, char *const argv[]); // 文件名  常用*****
int execvpe(const char *file, char *const argv[],char *const envp[]);

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

/**
 * date +%s
 * */

int main()
{
    puts("begin()");

    int err = execl("/bin/date", "date", "+%s",NULL);
    perror("execl()"); // 如果成功了，已经替换成其他映像，不会回来，如果回来，一定出错，结束
    exit(1);

    puts("end()");
    return 0;
}

在这里插入图片描述
不会再打印end，已经跑路了

./ex > /tmp/out

在这里插入图片描述
注意fflush的使用
文件是全缓冲， 需要使用fflush（否则需要等缓冲满了，自动冲洗）
终端及设备是行缓冲，有’\n’即可实现刷新

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

/**
 * date +%s
 * */

int main()
{
    puts("begin()");

    fflush(NULL);
    execl("/bin/date", "date", "+%s",NULL); // pid 并没变化，却执行了其他进程
    perror("execl()"); // 如果成功了，已经替换成其他映像，不会回来，如果回来，一定出错，结束
    exit(1);

    puts("end()");
    return 0;
}

shell处理外部命令的思路

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


int main()
{
    while (1)
    {
        prompt();
        getline();
        parse(); // 解析
        if (内部命令)
        {

        }
        else
        {
            // 外部命令
            pid = fork();
            if (pid < 0)
            {
				perror();
				exit(1);
            }
            else if (pid == 0)
            {
                execXX();
                perror();
                exit(1);
            }
            else
            {
                wait(); // 等待收尸
            }
        }
    }
    
    return 0;
}


 #include <string.h>
 char *strtok(char *str, const char *delim);

解析代码：

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

#define DELIMS " \t\n"

struct cmd_st
{
    glob_t glob_res;
};

static void prompt()
{
    printf("mysh$ ");
}

// 解析
static void parse(char* line, struct cmd_st * res)
{
    char * tok;
    int i = 0;
    while (1)
    {
        tok = strsep(&line, DELIMS);
        if (tok == NULL)
            break;
        if (tok[0] == '\0')
            continue;
        // pat, GLOB_NOCHECK 如果没有匹配模式的，就返回tok字串 eg: ls 那么就返回ls
        glob(tok, GLOB_NOCHECK | GLOB_APPEND * i, NULL, &res->glob_res);
        i = 1; // 只有第一次不进行加入eg ls -a  解析ls的时候不是append,是直接覆盖res，后面是-a是append  res为ls -a
    }
}

int main()
{
    char * linebuf = NULL;
    size_t linebuf_size = 0;
    struct cmd_st cmd;
    while (1)
    {
        prompt();
        // char** buf, size_t* n, file* stream
        if (getline(&linebuf, &linebuf_size, stdin) < 0)
        {
            break;
        }

        parse(linebuf, &cmd); // 解析
        if (0)
        {
            // to do  内部命令
        }
        else
        {
            // 外部命令
            pid_t pid = fork();
            if (pid < 0)
            {
                perror("fork()");
                exit(1);
            }
            else if (pid == 0)
            {
                // execL();  可变参数  前三个不用  eg 第一个参数就是ls  后面是pathv，参数中包括了命令本身，
                execvp(cmd.glob_res.gl_pathv[0], cmd.glob_res.gl_pathv);
                perror("execvp()");
                exit(1);
            }
            else
            {
                wait(NULL); // 等待收尸
            }
        }
    }
    
    return 0;
}

  1. 用户权限及组权限
    u+s
    g+s
    uid_t getuid(); // 返回实际用户id + e表示有效的
    getgid(); // 返回组id
    setuid(uid_t uid); // 设置实际用户id
    setgid(gid_t gid);
    setreuid(uid_t ruid, euid); // 交换实际uid和有效uid
    setregid();
    seteuid();
    setegid();

  2. 观摩课：解释器文件
    #！脚本标记
    加载后面的解释器
    使用该解释器，解释文件中的命令(此时第一行是#开头，那就将其解释为注释)

#!/bin/bash

ls
whoami
cat /etc/shadow
ps

  1. system(); // execute a shell command
    execl(“/bin/sh”, “sh”, “-c”, command, (char *) NULL);
    相当于fork exec wait的简单封装

  2. 进程会计
    acct

  3. 进程时间(time命令)
    time 命令

#include <sys/times.h>
clock_t times(struct tms *buf);

 struct tms {
     clock_t tms_utime;  /* user time */
     clock_t tms_stime;  /* system time */
     clock_t tms_cutime; /* user time of children */
     clock_t tms_cstime; /* system time of children */
};
  1. 守护进程
    脱离控制终端
    会话的领导者
    进程组的领导者

会话/终端：一个终端的登录就产生了一个会话
session的标识sid

最多可以有一个前台进程组
后台不能接受输入输出

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

pid_t setsid(void); // group leader进程是不可以进行调用该函数的，也就是父进程是无法调用的，必须是子进程调用，因为守护进程不需要收尸

调用setsid的进程会成为当前新进程组的leader，并脱离控制终端
成为守护进程(父进程就是init 1号) 类型为？

getpgrp(); 当前进程组的id
getpgid(pid_t) 根据进程号获取进程组号

  1. 系统日志书写
    每个程序都有必要写系统日志，系统日志/var/log
    但不能任何程序都有权限写

syslogd服务去写，控制权限的服务

单实例守护进程：锁文件/var/run/sshd----无法多次启动一个进程，由此控制
开机启动脚本：/etc/rc*

#include <syslog.h>
// 人物 特殊要求 来源
void openlog(const char *ident, int option, int facility); // 写
// 级别 内容 
void syslog(int priority, const char *format, ...); // 提交内容
void closelog(void);

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

#define FNAME "/tmp/out"

static int daemonize(void)
{
    FILE* fd;
    pid_t pid = fork();
    if (pid < 0)
    {
        perror("fork");
        exit(1)
    }
    else if (pid > 0)
    {
        exit(0); // 父进程退出
    }
    else
    {
        // 脱离终端 012需要重定向  不能定向到终端
        fd = open("dev/null", O_RDWR);
        if (fd < 0)
        {
            perror("open");
            return (-1);
        }
        // 守护进程打开文件，使其具有文件描述符012， 任何一个读写err的库例程都不会产生效果
        dup2(fd, 0);  // 文件输入输出重定向
        dup2(fd, 1);
        dup2(fd, 2);
        if (fd < 2)
            close(fd);

        setsid(); // 子进程设置为守护进程 
        chdir("/"); // 工作路径设置到根目录 因为从父进程继承来的工作目录可能是个挂载的目录，
        // 如果守护进程的工作目录也是一个挂载目录，那么该文件系统将不可以被卸载
        // umask(0);
        return 0;
    }
}

int main()
{
    // 人物：任意字段-一般用文件名,  pid,   守护进程类别
    openlog("mydaemon", LOG_PID, LOG_DAEMON);
    // 守护进程
    if (daemonize())
    {
        syslog(LOG_ERR, "init failed");
        exit(1);
    }
    else
    {
        syslog(LOG_INFO, "successed");
    }
    
    // 守护进程做的任务
    FILE* fp = fopen(FNAME, "w+");
    if (fp == NULL)
    {
        syslog(LOG_ERR, "write file failed");
        exit(1);
    }

    syslog(LOG_INFO, "%s opened", FNAME);
    for (int i = 0; ;i++)
    {
        fprintf(fp, "%d", i);
        fflush(NULL);
        syslog(LOG_INFO, "%d wrote", i);
        sleep(1);
    }
    closelog();
    fclose(fp);

    return 0;
}
晗光。
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Linux进程基础——创建子进程
Sixer
09-11 2806
Linux进程基础 主要概念： 父进程与子进程 ​ 创建新进程的那个进程称为父进程，新进程称为子进程。使用 fork() 函数创建子进程。 实验目的： ​ 创建子进程，分别在父进程和子进程中打印各自的 PID。 相关函数： #include <sys/types.h> #include <unistd.h> pid_t fork(void) //创建进程 pid_t getpid(void) //获取进程ID pid_t getppid(void) //获取父进程ID 代码：
进程概念——Linux
热门推荐
一些七零八碎的知识点
01-22 1万+
Linux进程基本概念
进程控制编程——创建进程1
weixin_43258242的博客
11-21 296
进程： 进程是一个具有一定独立功能的程序的一次运行活动，同时也是资源分配的最小单元。 （ctrl +z——》切到后台） （fg ——》切到前台） （ps - elf ——&gt;查看运行的所有进程） 程序是放到磁盘的可执行文件 进程是指程序执行的实例 程序与进程的关系 （1）进程是动态的，程序是静态的：程序是有序代码的集合；进程是程序的执行。通常进程不可在计算机之间迁移；而程序通常...
【Linux】进程控制 —— 进程创建/终止/等待
Hello_World_213的博客
09-20 2048
[Linux]进程创建/终止/等待, fork之后系统都做了什么, 进程终止时的退出码以及三种退出状态, 进程等待wait与waitpid, 阻塞等待与非阻塞等待, 轮询检测方案
【Linux】进程概念——父子进程、僵尸进程和孤儿进程
Dooo_yh的博客
03-31 8694
透彻了解父子进程、僵尸进程、孤儿进程
计算机操作系统实验一 进程创建模拟 源代码
01-30
在本实验中，我们将聚焦于操作系统中的一个核心概念——进程的创建。通过使用C语言来模拟这一过程，我们可以更深入地理解操作系统如何管理程序的执行。 首先，我们要了解什么是进程。在操作系统中，进程是正在执行...
Linux安全攻略——僵尸进程.pdf
09-07
1. 进程创建：使用fork()函数创建新的进程，新进程继承父进程的所有资源。 2. 进程执行：进程执行自己的任务，使用系统资源。 3. 进程结束：进程结束自己的任务，释放系统资源。 僵尸进程 僵尸进程是指已经结束的...
linux进程之fork创建新进程.zip
06-05
`fork()`函数的调用会产生一个与当前进程（父进程）几乎完全一样的新进程——子进程。这两个进程拥有相同的代码段、数据段、堆和栈，但它们各自拥有独立的进程ID（PID）和资源分配。`fork()`调用成功后，会在父进程...
操作系统实验1 进程控制
04-10
操作系统实验1 进程控制是计算机科学领域中的一个重要实践环节，它主要涉及到操作系统核心功能之一——进程管理。在这个实验中，我们将使用C++编程语言来模拟和实现进程控制的基本概念和机制，这对于理解和掌握操作...
详解Android进程和线程
09-02
默认情况下，应用的所有组件（如Activity、Service等）都在同一个进程和线程——主（Main）线程中运行。这个主线程也被称为UI线程，负责处理用户界面的更新和事件响应。由于Android遵循单线程模型，UI操作不是线程...
Linux小程序——进度条
最新发布
m0_66182473的博客
07-23 668
进度条
Linux：基础命令学习
qq_55038440的博客
07-20 892
实例：-F根据文件类型在列出的文件名称后加一符号。实例： -R 递归显示目录中的所有文件和子目录。. 开头的隐藏文件也会列出。可执行文件则加 "*"，用于显示目录文件信息。
【Linux服务器Java环境搭建】010在linux中安装Redis，以及对Redis的配置与远程连接
liuzhenhe1988的专栏
07-19 1011
好久没有更新博客了，今天下了班回到家，看到电脑桌上尘封已久的《Spring Boot应用开发实战》，翻开目录想起来之前写的系列【Linux服务器Java环境搭建】还未完结，那就继续吧，今天主要是按linux服务器中安装和配置redis。本系列其他文章，请查看系列【Linux服务器Java环境搭建】
linux学习笔记整理: 关于linux:Shell脚本 2024/7/20；
gzx233的博客
07-20 883
Shell脚本的使用
Linux 权限
includemainprinf的博客
07-18 687
在Linux操作系统中，权限管理是一个至关重要的概念，它确保了系统的安全性和稳定性。同时可以在工作中，设置对象的权限，就算我们很多人使用一台服务器，我们也可以让别人看不到我们文件的内容，或者让别人无法对自己的文件进行操作！
Linux（CentOS7）部署PHP-7.2.17源码包
thetender的博客
07-18 1165
LAMP系统安装 通过PHP的源码包部署PHP-7.2.17版本
Linux HOOK机制与Netfilter HOOK
Flashing-C的博客
07-18 784
在计算机中基本所有的软件程序都可以通过hook方式进行行为拦截，hook方式就是改变原始的执行流。 Linux常见的HOOK方式：1、修改函数指针。2、用户态动态库拦截。①利用环境变量LD_PRELOAD和预装载机制进行HOOK；②利用函数ptrace可实现对已运行的程序进行HOOK；3、内核态系统调用拦截。通过修改全局系统调用表，对系统调用进行劫持；4、堆栈式文件系统拦截。5、LSM。6、Netfilter HOOK。
Linux RV1126开发板 + AIR780E模块配置RNDIS网络
wxj280306451的博客
07-18 1039
此时，使用lsusb命令可以看到 AIR780E在开发板上枚举出来的PID和VID1d91 和 0001 就是VID和PID。
Linux——多路复用之select
kkbca的博客
07-19 1162
在前面，我们学习了五种IO模型，对IO有了基本的认识，知道了select效率很高，可以等待多个文件描述符，那他是如何等待的呢？我们又该如何使用呢？
Android进程管理深入解析：从创建到回收
本文聚焦于Android进程管理的第一个主题——进程的创建，这对于理解应用程序在Android设备上的行为至关重要。 Android的进程创建流程涉及多个核心组件，首先是`app_process`，它位于`frameworks/base/cmds/app_...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值