【Linux】进程控制

最新推荐文章于 2024-05-20 09:02:22 发布
最新推荐文章于 2024-05-20 09:02:22 发布
阅读量381 收藏 28
点赞数 33
分类专栏： 学会Linux 文章标签： linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/VHhhbb/article/details/134332455
版权

🌇个人主页：平凡的小苏
📚学习格言：命运给你一个低的起点，是想看你精彩的翻盘，而不是让你自甘堕落，脚下的路虽然难走，但我还能走，比起向阳而生，我更想尝试逆风翻盘。
🛸C++专栏：Linux内功修炼
家人们更新不易，你们的👍点赞👍和⭐关注⭐真的对我真重要，各位路 过的友友麻烦多多点赞关注。欢迎你们的私信提问，感谢你们的转发！ 关注我，关注我，关注我，你们将会看到更多的优质内容！！

在这里插入图片描述

一、子进程的创建

1、fork函数的概念

在linux中fork函数是非常重要的函数，它从已存在进程中创建一个新进程。新进程为子进程（子进程的PID是0），而原进程为父进程。

#include <unistd.h>
pid_t fork(void);

返回值：fork创建子进程成功后，会给父进程返回子进程的PID，给子进程返回0，失败则返回-1。

为什么要让父进程拿到子进程的PID?因为子进程变为僵尸状态后，需要父进程读取子进程的退出信息并回收资源。

操作系统将会给创建成功的子进程：

1、给子进程分配新的内存块和内核数据结构（PCB、进程地址空间、页表等，并构建对应的映射关系）；

2、将父进程的部分数据结构内容拷贝至父进程；

3、把子进程添加到系统进程列表中；

4、fork返回，调度器开始调度。

2、如何理解fork有两个返回值

fork的原理

在这里插入图片描述

在fork函数return之前，就已经有了父子两个进程，给父进程返回子进程的PID，给子进程返回0，失败则返回-1。

利用这个特性，我们可以用变量接收返回值，根据fork返回值不同让父子进程执行不同的代码。

#include <stdio.h>
#include <unistd.h>
int main()
{
    pid_t id=fork();
    if(id==0)
    {
        printf("子进程:pid=%d,ppid=%d | grobal_val=%d,&grobal_val=%p\n",getpid(),getppid(),grobal_val,&grobal_val);
    }
    else if(id>0)
    {
        printf("父进程:pid=%d,ppid=%d | grobal_val=%d,&grobal_val=%p\n",getpid(),getppid(),grobal_val,&grobal_val);
        sleep(1);
    }
    else 
    {
        printf("fork error\n");
        return 1;
    }
    return 0;
}

pid_t id=fork()这句代码父子进程谁先返回不确定。谁先返回，谁就在虚拟内存中写入id的值，后返回的进程由于进程的独立性将会发生写时拷贝。所以，我们可以看到父子进程的id变量的虚拟地址是一样的，但是内容却不一样。

3、fork调用失败的场景

系统中的进程数达到了最大限制。

二、进程的终止

1、进程退出的常见场景

有如下三种退出的方式：

  • 1、代码跑完，结果正确
  • 2、代码跑完，结果不正确
  • 3、代码没跑完，程序异常了

2、进程退出码

我们先前写C/C++代码的时候，都会在入口函数main函数开始写，我们总是喜欢在结尾的时候给上一个return 0，继而引发出了如下的两个问题：

return 0，给谁return？
为何是0？其它值可以吗？
下面一次解决：

1、return 0，给谁return？
给父进程，具体理由在下面会有讲解。

2、为何是0？其它值可以吗？
返回值代表的是进程代码跑完，结果是否正确，如果是0，则成功，非零则失败。所以我们在写一个程序的时候，如果测试结果正确，这里我们可以给上return返回值0，可如果不正确，我们return的应该是其他值以此表示结果失败，只不过我们平时都无脑return 0了，准确说是不太正确的。

此外，失败虽是用非零值表示，可也是有讲究的，结果成功都是用0表示，结果失败反倒用不同的数字来表示，以此表示失败的不同原因。

所以我们把main函数的return返回值称之为进程退出码！！进程退出码表征了进程推出的信息，此信息是要给父进程去读取的。

示例：

我们可以通过如下的指令查看退出码：

echo $?
//$?表示在bash中，最近一次执行完毕时，对应进程的退出码！

在这里插入图片描述

在这里插入图片描述

再比如我们平时在命令行输入的指令，诸如ls、cd……类的，其退出码均为0，表示结果正确，可是当你随便输入一条错误指令的时候，其退出码则是某一数字表示结果错误：

在这里插入图片描述

问：一般而言，失败的的非零值我该如何设置呢？以及默认表达的含义？

  • C语言当中的strerror函数可以通过错误码，获取该错误码在C语言当中对应的错误信息：

在这里插入图片描述

在这里插入图片描述

  • 总结：错误码退出码可以对应不同的错误原因，方便定位问题！

3、进程退出的常见情况

正常终止：

  • 1、在main函数中return代表进程退出，非main函数return代表函数调用结束，这两点要注意。
  • 2、在自己的代码任意地点中，调用exit()。
  • 3、_exit

异常终止：

  • ctrl + c，信号终止

3.1、库函数exit

函数原型：

#include <stdlib.h>
void exit(int status);

库函数exit在进程退出后，会主动刷新缓冲区。

3.2、系统调用接口_exit

函数原型：

#include <unistd.h>
void _exit(int status);

系统调用_exit在进程退出后，并不会主动刷新缓冲区。

三、进程等待

1、进程等待的必要性

子进程退出后会进入僵尸状态，父进程通过进程等待的方式，获取子进程的退出信息，回收子进程资源，让子进程结束僵尸状态。当然，在子进程没有退出时，父进程只能阻塞等待子进程变成僵尸状态。

2、进程等待的方法

头文件：

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

2.1、系统调用wait

函数原型：

pid_t wait(int* status);

返回值：等待成功被等待进程的pid，失败返回-1。

参数：status输出型参数，获取子进程退出码和退出状态,不关心则可以设置成为NULL。通过wait让父进程获取子进程的PID。

#include <stdio.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>
#include <stdlib.h>
int main()
{
    pid_t id = fork();
    if(id == 0)
    {
        int cnt = 5;
        while(cnt--)
        {
            printf("子进程: %d,父进程: %d\n",getpid(),getppid());
            sleep(1);
        }
        exit(0);

    }

    sleep(5);
    pid_t ret = wait(NULL);
    if(ret > 0)
    {
        //父进程
        printf("等待成功\n");
    }
    return 0;
}

在这里插入图片描述

在这里插入图片描述

2.2、系统调用waitpid

函数原型：

pid_t waitpid(pid_t pid,int* status,int options);

返回值：当正常返回的时候waitpid返回收集到的子进程的进程PID；如果设置了选项WNOHANG,而调用waitpid发现没有已退出的子进程可收集,则返回0；如果调用中出错,则返回-1,这时errno会被设置成相应的值以指示错误所在；

参数：

PID：

PID=-1,等待任一个子进程。与wait等效。PID>0，等待进程为PID的子进程。

status:

WIFEXITED(status): 若为正常终止子进程返回的状态，则为真。（查看进程是否是正常退出）

WEXITSTATUS(status): 若WIFEXITED非零，提取子进程退出码。（查看进程的退出码）

#include <stdio.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>
#include <stdlib.h>
int main()
{
    pid_t id = fork();
    if(id < 0) {
        perror("fork");
        return 1;
    }
    else if(id == 0)
    {
        //int *p = NULL;
        // child
        int cnt = 5;
        while(cnt)
        {
            printf("I am child, pid:%d, ppid:%d, cnt: %d\n", getpid(), getppid(), cnt);
            cnt--;
            sleep(1);
            //*p = 100;
        }
        exit(11);
    }
    else
    {
        int status = 0;
        pid_t ret = waitpid(id, &status, 0);
        if(ret > 0)
        {
            // 7F: 0111 1111
            // printf("wait success, ret: %d, exit sig: %d, exit code: %d\n", ret, status&0x7F, (status>>8)&0xFF);
            if(WIFEXITED(status))
            {
                printf("进程是正常跑完的, 退出码:%d\n", WEXITSTATUS(status));
            }
            else{
                printf("进程出异常了\n");
            }
        }
        else if(ret < 0)
        {
            printf("wait failed!\n");
        }
          
    }
    return 0;
}

options:

WNOHANG: 若PID指定的子进程没有结束，则waitpid()函数返回0，不予以等待。若正常结束，则返回该子进程的PID。

设置WNOHANG表示非阻塞等待设置为0为阻塞等待

2.3、阻塞和非阻塞等待

阻塞式等待：当父进程调用wait/waitpid（第三个参数为0）等待子进程，如果子进程暂未退出，父进程会被阻塞，暂停运行，如果父进程刚好没事干，可以选择使用阻塞等待。

非阻塞式等待：当父进程调用waitpid（第三个参数为WNOHANG）等待子进程，如果父进程检测到子进程未退出，父进程并不会原地等待，而是继续执行自己的代码。如果使用while循环，便能达到轮询的效果。

非阻塞式等待不会占用父进程的精力，父进程可以在轮询的过程中做其他事情：

#include<stdio.h>
#include<unistd.h>
#include<stdlib.h>
#include<sys/types.h>
#include<sys/wait.h>
int main()
{
	pid_t id = fork();
	if (id == 0)
	{
		//子进程
        int cnt = 5;
		while (cnt--)
		{
			printf("我是子进程，我的PID：%d, 我的PPID：%d\n", getpid(), getppid());
			sleep(1);
		}
		exit(104);
	}
	else if (id > 0)
	{
		//父进程
		//基于非阻塞的轮询等待方案
		int status = 0;
		while (1)
		{
			pid_t ret = waitpid(-1, &status, WNOHANG);
			if (ret > 0)
			{
				printf("等待成功，%d，退出信号是：%d，退出码是：%d\n", ret, status & 0x7F, (status >> 8) & 0xFF);
				break;
			}
			else if (ret == 0)
			{
				//等待成功了，但是子进程没有退出
				printf("子进程好了没，奥，还没，那么我父进程就做其他事情啦...\n");
				sleep(1);
			}
			else
			{
				//出错了，暂时不处理
			}
		}
	}
	else
	{
		//do nothing   
	}
	return 0;
}

在这里插入图片描述

注：ret为0时等待成功，但是子进程没有退出，循环等待，大于0则子进程退出，小于0为等待失败

3、status的意义

wait和waitpid，都有一个status参数，该参数是一个输出型参数，由操作系统填充。

如果传递NULL，表示不关心子进程的退出状态信息。

否则，操作系统会根据该参数，将子进程的退出信息反馈给父进程。

status不能简单的当作整型，可以当作位图来看待。（只研究status低16比特位）：

在这里插入图片描述

解释上图：

  • 在status的低16比特位当中，高8位表示进程的退出状态，即退出码。进程若是被信号所杀，则低7位表示终止信号，而第8位比特位是core dump标志。

  • core dump表示是否正常结束

四、进程程序替换

1、进程程序替换的概念

用fork创建子进程后执行的是和父进程相同的程序(但有可能执行不同的代码分支),子进程往往要调用一种exec函数以执行另一个程序。当进程调用一种exec函数时,该进程的用户空间代码和数据完全被新程序替换,从新程序的启动例程开始执行。调用exec并不创建新进程,所以调用exec前后该进程的id并未改变。

替换函数：

#include <unistd.h>`
//execve的封装
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[]);
//系统调用
int execve(const char *filename, char *const argv[],char *const envp[]);

l(list) : 表示参数采用列表 ；

p(path) : 带p，不用传入地址，传入可执行程序的名字即可，它会自动去环境变量PATH中寻找该可执行程序的地址；

v(vector) :执行参数放入数组中，统一传递；

e(env) : 可以传入自己写的环境变量。

1、通过execl函数调用ls命令：

#include <stdio.h>
#include <unistd.h>
int main()
{
    printf("process is running·····\n");
    execl("/usr/bin/ls"/*要执行的程序*/,"ls","--color=auto","-a","-l",NULL/*如何执行*/);//一定要用NULL结尾
    printf("process is down·····\n");//这句话并不会被打印，因为后续代码和数据已经被execl函数替换了
    return 0;
}

在这里插入图片描述

2、通过execv调用另一个文件打印出环境变量

//mycommand.c文件
#include<stdio.h>
#include<unistd.h>
#include<stdlib.h>
#include<sys/types.h>
#include<sys/wait.h>
int main()
{
    pid_t id = fork();
    if(id == 0)
    {
        printf("before: I am a process, pid: %d, ppid: %d\n",getpid(),getppid());

        char* const myargv[] = {
           "otherExe",
            "_a",
            "_b",
            "_c",
            NULL 
        };

        execv("./otherExe",myargv);
        printf("after: I am a process, pid: %d, ppid:%d\n",getpid(),getppid());
        exit(1);
    }

    pid_t ret = waitpid(id,NULL,0);
    if(ret > 0) printf("wait success, father pid:%d, ret id: %d\n",getpid(),ret);
    sleep(5);
    return 0;
}

//otherExe.cpp文件

#include <iostream>
using namespace std;
int main(int argc,char* argv[], char*env[])
{
    cout << argv[0] << " begin running " << endl;
    cout << "这是命令行参数" << endl;
    for(int i = 0; argv[i];i++)
    {
        cout << i << " : " << argv[i] << endl;
    }
    cout << "这是环境变量" << endl;
    for(int i = 0; env[i]; i++)
    {
        cout << i << " : " << env[i] << endl;
    }
    cout << argv[0] << " stop running " << endl;
    return 0;
}

在这里插入图片描述

3、通过execle函数调用外部程序并使用自定义环境变量：

#include<stdio.h>
#include<unistd.h>
#include<stdlib.h>
#include<sys/types.h>
#include<sys/wait.h>
int main()
{

    putenv((char*)"MYENV=654321");
    extern char** environ;
    pid_t id = fork();
    if(id == 0)
    {
        printf("before: I am a process, pid: %d, ppid: %d\n",getpid(),getppid());

        char* const myargv[] = {
           "otherExe",
            "_a",
            "_b",
            "_c",
            NULL 
        };
        //使用自定义的环境变量
        char* const _env[]={(char*)"MYENV=12345",NULL};
        execle("./otherExe","otherExe",NULL,_env);
        //extern char** environ;
        //系统环境变量不传，进程也能获取
        //execle("./otherExe","otherExe","-a", "-w", "-t", NULL, environ);
        //execv("./otherExe",myargv);
        printf("after: I am a process, pid: %d, ppid:%d\n",getpid(),getppid());
        exit(1);
    }

    pid_t ret = waitpid(id,NULL,0);
    if(ret > 0) printf("wait success, father pid:%d, ret id: %d\n",getpid(),ret);
    sleep(5);
    return 0;
}

2、进程程序替换的原理

  • 前面我们学习到，当fork创建子进程的时候，子进程的PCB、虚拟地址空间都以父进程为模板，页表中的代码段指向的是父进程中的代码段，数据也以写时拷贝的方式来和父进程进行共享，如果现在有一个全新的程序b.exe，并且我现在不想让子进程执行任何父进程相关的代码以及访问父进程的数据，并执行的是a.exe程序，此时把b.exe的程序加载到物理内存上，让子进程重新调整自己的页表映射，使其指向新的b程序的代码和数据，这种过程就叫做程序替换。

在这里插入图片描述

总结程序替换的原理：

  • 将磁盘中的程序，加载入内存结构
    重新建立页表映射，谁执行程序替换，就重新建立谁的映射，最终达到的效果就是让父进程和子进程彻底分离，并让子进程执行一个全新的程序！！！

    问1：当进行程序替换时，有没有创建新的进程？

  • 进程程序替换后，该进程对应的PCB、进程地址空间以及页表等数据结构均没有发生改变，只是重新建立了一下物理内存中的映射关系罢了，它的内核对应的数据结构没有发生变化，他的pid也没有发生变化，也就没有创建新的进程，只不过是让进程执行不同的程序罢了！！！
    问2：子进程进行进程程序替换后，会影响父进程的代码和数据吗？

  • 子进程刚被创建时，与父进程共享代码和数据，但当子进程需要进行进程程序替换时，也就意味着子进程需要对其数据和代码进行写入操作，这时便需要将父子进程共享的代码和数据进行写时拷贝，此后父子进程的代码和数据也就分离了，因此子进程进行程序替换后不会影响父进程的代码和数据。

3、exec*()系列函数的返回值

exec()函数仅在发生错误时返回。返回值为-1，设置errno以指示错误。

可以看到exec系列函数调用成功后并没有返回值，因为exec一旦被调用成功，后续代码将被覆盖，根本没机会用到返回值。

五、实现简易版本的Shell

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

#define LEFT "["
#define RIGHT "]"
#define LABLE "#"
#define DELIM " \t"
#define LINE_SIZE 1024
#define ARGC_SIZE 32
#define EXIT_CODE 44

int lastcode = 0;
int quit = 0;
extern char** environ;
char commandline[LINE_SIZE];
char* argv[ARGC_SIZE];
char pwd[LINE_SIZE];
char myenv[LINE_SIZE];
const char* Getusername()
{
    return getenv("USER");
}

const char* Gethostname()
{
    return getenv("HOSTNAME");
}

void Getpwd()
{
    //使用系统调用获取
    getcwd(pwd,sizeof(pwd));
}

void interact(char* cline, int size)
{
    Getpwd();
    printf(LEFT"%s@%s %s"RIGHT""LABLE" ",Getusername(),Gethostname(),pwd);
    char *s = fgets(cline,size,stdin);//输入命令
    assert(s);//断言fgets有没有出错
    (void)s;//为了没有警告
    cline[strlen(cline)-1] = '\0';//为了将输入命令的回车符去掉
}

int splitstring(char* cline, char* argv[])
{
    int i = 0;
    argv[i++] = strtok(cline,DELIM);
    while(argv[i++] = strtok(NULL,DELIM));//字符串解析
    return i - 1;
} 

void NormalExcute(char* argv[])
{
    pid_t id = fork();
    if(id < 0)
    {
        perror("fork");
        return;
    }
    else if(id == 0)
    {
        //让子进程执行命令
        execvp(argv[0],argv);
    }
    else 
    {
        int status = 0;
        pid_t rid = waitpid(id,&status,0);
        if(rid == id)
        {
            lastcode = WEXITSTATUS(status);
        }
    }
}

int buildCommand(int argc, char* argv[])
{
    if(argc == 2 && strcmp(argv[0],"cd") == 0)
    {
        chdir(argv[1]);
        Getpwd();
        sprintf(getenv("PWD"), "%s", pwd);
        return 1;
    }
    else if(argc == 2 && strcmp(argv[0],"export") == 0)
    {
        strcpy(myenv,argv[1]);
        putenv(myenv);
        return 1;
    }
    else if(argc == 2 && strcmp(argv[0],"echo") == 0)
    {
        if(strcmp(argv[1],"$?") == 0)
        {
            printf("%d\n",lastcode);
            lastcode = 0;
        }
        else if(*argv[1] == '$')
        {
            char* val = getenv(argv[1] + 1);
            if(val) printf("%s\n", val);
        }
        else 
        {
            printf("%s\n",argv[1]);
        }
        return 1;
    }

    //特殊处理ls，使它有颜色
    if(strcmp(argv[0],"ls") == 0)
    {
        argv[argc++] = "--color";
        argv[argc++] = NULL;
    }

    return 0;
}

int main()
{
    while(!quit)
    {
        //交互问题，获取命令行
        interact(commandline,sizeof(commandline));

        //子串分割的问题，解析命令行
        int argc = splitstring(commandline,argv);
        if(argc == 0) continue;
        
        //内建命令
        int n = buildCommand(argc,argv);        

        //普通命令的执行
        if(!n) NormalExcute(argv);
    }
    return 0;
}
平凡的小苏
关注
  • 33
    点赞
  • 踩
  • 28
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 28
    评论
专栏目录
linux实验四 进程控制实验
02-09
1、掌握进程的概念，明确进程和程序的区别 2、认识和了解并发执行的实质。 3、学习进程创建方法及进程树的概念。 二、实验内容 1、进程的创建 编写一段程序，使用系统调用fork( )创建两个子进程，在系统中有一个父...
Linux进程控制详解及实例
09-15
主要介绍了Linux进程控制详解及实例的相关资料,需要的朋友可以参考下
Linux 进程控制与进程互斥（附源代码）（附实验报告）
03-07
1、利用fork函数创建新进程，并根据fork函数的返回值，判断自己是处于父进程还是子进程中； 2、在新创建的子进程中，使用exec类的函数启动另一程序的执行；...5、分析Linux系统下多进程与多线程中的区别。
linux进程控制
09-14
linux进程控制
Linux 进程控制与进程通信1
08-08
（1）Fork的返回值有多种，其用法如下Pid=fork() （5）fork出错可能有两种原因：（1）当前的进程数已经达到了系统规定的上限，这时errno的值被
linux---进程通信
m0_74979625的博客
05-17 550
提示：以下是本篇文章正文内容，下面案例可供参考。
【Linux】Centos7安装Redis
m0_72166275的博客
05-17 316
Reid 官网下载 Redis 7.2。
Linux 三十六章
一怀明月的博客
05-17 986
信号量 sem_init sem_destroy sem_wait sem_post 基于环形队列的CP问题 环形队列的生产者消费者模型 线程池 localtime时间戳转化 mkdir系统调用 bind绑定成员函数 懒汉饿汉单例模式 懒汉模式： 饿汉模式： 懒汉和饿汉相同点： 线程池源码实现
Linux动静态库
2301_80163789的博客
05-14 629
在程序翻译的链接阶段，其实就是把一堆.o文件链接在一起形成.exe文件。如果一个程序中需要链接很多个.o文件，那么这些.o文件就需要被打包才方便管理，**库文件本质就是把.o文件打包。**库文件是一种提高开发效率的手段。对于静态库，使用静态库形成可执行程序后，静态库被加载到了可执行程序的代码里，不需要让系统知道静态库在哪里；但对于动态库，由于动态库不加载到可执行程序里，而是动态加载到内存中，所以使用动态库要告诉系统动态库在哪（因为是系统来加载动态库）。动态库在编译时代码不会被复制到可执行文件中，而是。
【linux】linux中免交互命令expect原理与应用实战
最新发布
景天科技苑
05-20 1436
Expect 是基于 Tcl 的相对简单的一个免费的脚本编程工具语言，用来实现 自动和交互式任务程序进行通信，无需人的手工干预。比如 SSH、FTP 等，这些 程序正常情况都需要手工与它们进行交互，而使用 Expect 就可以模拟人手工交 互的过程，实现自动的和远程的程序交互，从而达到自动化运维的目的。
操作系统 实验13 批处理操作接口3：引用与命令替换
m0_63093530的博客
05-14 155
结果：第一个和第三个命令是错的，第二个和第四个命令是对的。echo "这是命令替换形式1...$date1"echo "$sv ++++加上另一些字符！2、输出字符串“China's panda”命令：echo China\'s panda。6、将命令date执行结果赋予变量date1。7、将命令date执行结果赋予变量date2。1、输出字符串“$Dollar”命令：echo \$Dollar。命令：date2=$(date)命令：date1=`date`
从零开始学习Linux（8）----自定义shell
lys20221113242的博客
05-14 244
shell从用户读入字符串“ls”，shell建立一个新的进程，然后在那个进程中运行ls程序并等待那个进程结束。然后shell读取新的一行输入，建立一个新的进程，在这个进程中运行程序，并等待这个进程结束。5. 父进程等待子进程退出（wait）3. 建立一个子进程（fork）4. 替换子进程（execvp）
Linux：网络管理命令之ss
hhd1988的专栏
05-17 814
Linux：网络管理命令之ss
linux中查找某个文件或文件夹
DN金猿的博客
05-18 245
locate命令将会在整个系统中搜索文件和文件夹，并通过正则表达式匹配以"/folder_name"结尾的路径。这将会在指定的路径（/path/to/search）中递归地列出所有文件和文件夹，并使用grep命令匹配以"/folder_name"结尾的行。该命令将会在指定的路径（/path/to/search）中查找名称为"folder_name"的文件夹。此方法与第2种方法类似，但使用了find命令来递归搜索文件夹，并使用grep命令来匹配以"/folder_name"结尾的行。
【Linux】进程信号(2万字)
2301_79585944的博客
05-14 867
世上有两种耀眼的光芒，一种是正在升起的太阳，一种是正在努力学习编程的你!一个爱学编程的人。各位看官，我衷心的希望这篇博客能对你们有所帮助，同时也希望各位看官能对我的文章给与点评，希望我们能够携手共同促进进步，在编程的道路上越走越远！提示：以下是本篇文章正文内容，下面案例可供参考好了，本篇博客到这里就结束了，如果有更好的观点，请及时留言，我会认真观看并学习。不积硅步，无以至千里；不积小流，无以成江海。
linux基于LD_PRELOAD机制的内存泄露检测工具
Hi20240217的博客
05-17 728
Valgrind影响性能且某些程序会报错,同时我们希望跳过初始化阶段,在程序稳定运行之后再去检测内存是否会持续增涨,为了更高效的记录内存分配情况,采用b+树.该程序会拦截malloc,free,calloc,realloc,new,delete。记录10层的PC指针,方便解析脚本定位调用的代码位置.
Linux的基础指令
asdssadddd的博客
05-14 946
常用选项:-f 或 --force 强行复制文件或目录, 不论目的文件或目录是否已经存在.-i 或 --interactive覆盖文件之前先询问用户.-r递归处理, 将指定目录下的文件与子目录一并处理. 若源文件或目录的形态, 不属于目录或符号链接, 则一律视为普通文件处理.-R 递归处理, 将指定目录下的文件及子目录一并处理.
Linux 上 Qt 一些常见报错解决办法~
逐天实验室 ( SCLB )
05-15 135
Linux 上 Qt 一些常见报错解决办法
Linux - 整理工作中常用的 Linux 命令（目录、文件、系统、进程、网络）持续更新~
CYK_byte的博客
05-16 956
整理了一下工作中常用的 Linux 命令（目录、文件、系统、进程、网络）
linux 进程控制
03-16
Linux 进程控制是指在 Linux 操作系统中对进程进行管理和控制的过程。Linux 提供了丰富的进程控制机制，包括进程创建、进程调度、进程通信、进程状态管理等。通过这些机制，用户可以对进程进行监控、调试、优化等...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 28
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

平凡的小苏

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值