【Linux】解锁系统编程奥秘，高效进程控制的实战技巧

最新推荐文章于 2024-10-06 11:52:56 发布
最新推荐文章于 2024-10-06 11:52:56 发布
阅读量2.8k 收藏 137
点赞数 136
文章标签： linux 服务器 运维 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_74808907/article/details/141950474
版权

进程控制

1. 进程创建

1.1. 操作系统的工作内容

当一个进程调用fork函数创建一个新的子进程时，操作系统会执行以下主要步骤：分配资源 -> 复制信息 ->添加到系统进程列表 -> 返回值 -> 调度器调度。

  • 分配资源：OS给子进程分配新的内存块(虚拟地址空间)，和其他必要的内核数据结构(PCB、页表等)。

  • 复制信息：将父进程的数据结构内容的一部分拷贝给子进程。

  • 添加到系统进程列表：OS会将子进程的信息添加到系统的进程管理数据结构中(进程链表等)，这样系统就能够管理和跟踪该子进程的状态和行为，调度器就能够感知新的进程并对其进行调度。

  • 返回值：为了区分父子进程，并允许它们执行不同的代码路径(if…else分流)。

  • 调度器调度：一旦fork操作完成，OS调度器就会重新安排CPU时间片，调度器可能会根据调度算法选择父进程、子进程、或系统中其他进程来执行，这意味着父进程，子进程可能会并发执行，但它们的执行顺序是不确定的。

1.2. fork常规用法

  1. 父进程希望复制自己，根据fork返回值使用if…else进行分流，从而使父子进程执行相同程序中不同的代码段。例如：父进程等待客户端请求，生成子进程来处理请求。

  2. 子进程要执行与父进程完全不同的程序。在这种情况下，子进程从fork返回后，通过调用exec()系列函数，在当前进程中加载并运行一个新的程序(进程程序替换)。例如：需要执行特定任务的子进程，这些任务与父进程的主要职责不同。

1.3. fork调用失败的原因

  1. 系统中有太多进程。如：一个学校能容纳的学生总数是有限的。

  2. 实际用户的进程数超过了限制。如：一个班级能容纳的学生总数是有限的。

2. 进程终止

2.1. main函数的返回值

2.1.1. 退出码

  1. 退出码：main函数的返回值，用来表示进程退出(终止)时，其执行结果是否正确。

  2. main函数返回0，表示代码执行成功，结果正确或者符合预期的。

  3. main函数返回非0，表示代码执行成功，结果是不正确的或程序遇到错误/异常情况。

代码执行成功，程序能够执行到main函数的末尾并返回，而不是说程序中的每一行都按预期执行了，因为有些错误不能被捕获或者导致程序提前退出了。

  1. 非0返回值，通常用于表示不同类型错误/异常的原因，退出码的字符串含义取决于程序的设计者。

  2. Shell(bash)会自动记录最近一次子进程执行完毕时的退出码，这个退出码可以通过echo $?获取。

echo $?

  • 功能：获取上一个命令的退出码。
#include<stdio.h>

int main()
{
    printf("hello world\n");
    
    return 0;  //退出码                                                              }

2.1.2. 退出码转化为错误描述的方式

  1. 使用语言或者系统自带的方法进行转化，例如：在linux中，使用strerror()函数。

char* strerror(int errnum)；

#include<stdio.h>
#include<string.h>                                                                                                                             
int main()
{
    for(int i = 0; i < 100; i++)
        printf("%d:%s\n", i, strerror(i));
    
    return 0;
}


2. 使用枚举类型进行自定义。

#include<stdio.h>
#include<string.h>

enum{
    success=0,
    malloc_err,
    open_err
};
  
const char* errorDesc(int code)
{
    switch(code)
    {
        case success:
            return "running sucess!";
        case malloc_err:
            return "malloc failure!";
        case open_err:
            return "file open failure!";
        default:
            return "unkown error!";                                                
     }
}
 
int main()
{
    int exit_code = malloc_err;
    printf("%s\n", errorDesc(exit_code));
 
   return 0;
}

2.2. 普通函数的返回值

执行结果：文件打开成功，fopen()返回指向该文件的指针；文件打开失败，fopen()返回NULL。

执行情况：返回了非空的FILE*指针，则可认为函数执行成功；返回了NULL，则可认为函数执行失败，需要进一步检查错误的原因(errno变量或调用perror()函数)。

  1. 普通函数退出，仅仅表示函数调用完毕。

  2. 函数也被称为子程序，与进程退出时返回退出码类似，函数执行完毕也会返回一个值，这个值通常用于表示函数的执行结果或状态。

  3. 调用函数，我们通常想看到两种结果：a.函数的执行结果(函数的返回值)；b.函数的执行情况(函数是否成功执行了预期的任务)，例如：fopen()函数的执行情况是通过其执行结果来间接表示。

2.2.1. 错误码

  1. errno是错误码，它是记录系统最后一次错误代码的一个整数值，不同值表示不同含义，在#include<errno.h>中定义。

  2. 当函数运行成功时，errno值不会被修改，因此我们不能通过测试errno的值来判断是否有错误存在，而应该在被调用的函数提示有错误发生时，再检查errno的值。

💡Tips：只有当库函数失败时，errno的值才会被设置。

#include<stdio.h>
#include<string.h>
#include<errno.h> 

int main()
{
      FILE* fp = fopen("log.txt","r");
      if(fp == NULL)  
          printf("%d:%s\n", errno, strerror(errno)); 
      
      return 0;
}

2.3. 进程退出的场景

退出码用于表示程序的执行结果或者终止的原因。

退出信号(kill)用于指示进程是正常退出，还是被信号杀死(每个信号都有不同的编号，编号表明异常的原因)。

  1. 代码执行完毕，结果正确 -> 退出信号=0、退出码=0。

  2. 代码执行完毕，结果不正确 -> 退出信号=0、退出码=!0。

  3. 代码没有执行完毕，进程异常终止 -> 退出信号=!0、退出码无意义。

💡Tips：任何进程最终的执行情况，我们都可以用两个数字来表明具体的执行情况，这两个数字分别为退出码、退出信号。

2.4. 进程退出的方式

2.4.1. main函数的返回

  1. 当程序执行到main函数的末尾，或者遇到return语句时，程序会返回main函数的返回值(退出码)。

  2. mian函数返回是程序主动退出的方式，即：正常终止进程。

2.4.2. 调用exit()、_exit()函数

一、exit()函数

void exit(int status)；

  1. 调用exit()是程序主动退出的方式，即：正常终止进程。

  2. exit()函数是C标准库提供的一个函数，在#include<stdlib.h>中定义，用于立即终止当前进程的执行，它会接受一个整形作为参数，该整形为进程的退出码。

  3. 调用exit()，程序会立即终止，exit()同时会执行清理操作(如：刷新所有的输出缓冲区、关闭通过fopen打开的文件、malloc开辟的内存等)，然后向操作系统返回退出码。

二、_exit()函数

void _exit(int status)；

  1. 调用_exit()是程序主动退出的方式，即：正常终止进程。

  2. _exit()函数是系统调用函数，在#include<unistd.h>中定义，用于立即终止当前进程的执行，它会接受一个整形作为参数，该整形为进程的退出码。

  3. _exit()不会自动执行exit()函数所执行的清理工作，需要确保在调用它之前，手动处理所有必要的清理工作，然后向操作系统返回退出码。

💡注意：main函数返回、调用exit()、_exit()函数，都表示程序主动退出，即：正常终止；接受到信号（如：ctrl c，信号终止)，表示程序被动退出，即：异常退出。

2.4.3. exit()、_exit()函数的区别

  1. exit()支持刷新缓冲区，_exit()不支持刷新缓冲区，因为exit中有缓存区，_exit中无缓冲区。

  2. 它们都是终止进程，但只有OS才有能力终止进程，因此exit()底层封装了_exit()，两者是上下层关系，。

💡Tips：我们之前谈及的缓冲区(进度条之类)，绝对不是操作系统级别的缓冲区，是标准C库管理的缓冲区（库级别的缓冲区)。

为什么语言具有可移植性和跨平台性？在库层面上，对系统强相关的接口进行了封装，从而屏蔽了底层差异。

3. 进程等待

3.1. 必要性

  1. 子进程先退出，如果父进程不回收其资源，子进程就变成僵尸状态，此状态无法被kill -9杀死，因为无法杀死已经死掉的进程，从而造成内存泄漏。

  2. 父进程需要知道派给子进程的任务完成的如何，即：获取子进程的退出信息。

子进程的退出信息(exit code、exit signal)，需要通过内核数据结构来维护，保存在子进程的task_struct中，属于内核数据。

💡Tips：总结：父进程通过进程等待的方式，回收子进程资源(必然)，获取子进程的退出信息(可选)。

3.2. 方式

3.2.1. wait

pid_t wait(int* status)；

  • 功能：等待任意一个子进程结束，并回收其资源。

  1. 返回值：调用成功，返回已经结束进程的PID，同时获取到了子进程的退出状态码；调用失败，返回-1，并设置错误码以指示错误的原因。

  2. 参数status：输出型参数，用于存储子进程的退出状态，由OS填充，如果不需要这个信息，可以传递NULL，否则，OS会根据该参数，将子进程的信息反馈给父进程。

3.2.2. waitpid

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

  • 功能：等待任意一个子进程或者指定的子进程结束，并回收其资源。

  1. 参数pid：如果pid = -1，等待任意一个子进程，与wait等效；如果pid > 0，等待其进程的PID与pid相等的子进程。

  2. 参数option：如果option = 0，则为阻塞等待；如果option = WNOHANG，则为非阻塞等待。

  3. 返回值：调用成功，返回收集到的子进程的PID，同时获取到了子进程的退出状态码；调用失败，返回-1，并设置错误码以指示错误的原因；如果为非阻塞等待，waitpid调用成功且没有收集到已结束的子进程，则返回0。

3.3. 阻塞等待、非阻塞状态

一、阻塞等待

  1. 定义：进程在发出某个请求(如：I/O操作、等待某个条件成立等)后，如果请求不能立即得到满足(如：数据未准备好、资源被占用等)，进程会被挂起，在此期间无法继续执行其他任务，直到等待条件满足或被唤醒。

故事理解：张三找李四辅导c语言，张三打电话给李四叫他下来，但李四正在寝室中复习期末，李四在复习的期间，和张三一直通着电话，张三不能做任何其他事情。打电话的过程 == 系统调用。

  1. 特点：

a.行为 -> 进程在等待期间无法执行其他任务。

b.触发方式 -> 等待由外部条件触发(如：数据到达、资源释放等)。

c.管理层面：由操作系统或者底层系统资源管理。

d.效率与并发性：效率低。

  1. 应用场景：实时性要求不高，等待时间相对比较短的情况，如：简单文件的读写操作。
#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<sys/types.h>
#include<sys/wait.h>

int main()
{
    pid_t id = fork();
      
    if(id == 0) //子进程
    {
        int cnt = 5;
        while(cnt)
        {
            printf("child is running, id:%d, ppid:%d\n", getpid(), getppid());
            sleep(1);
            cnt--;
        }
        exit(1); //子进程退出
    }
  
    int status = 0; //存储子进程退出状态
    pid_t rid = waitpid(id, &status, 0); //父进程等待 —— 阻塞等待
    if(rid > 0) //等待成功
        printf("wait success, status:%d\n", status);
    else if(rid == -1) //调用失败
        perror("wait error!\n");                                     
    
    return 0;
}


二、非阻塞等待

  1. 定义：进程在发出某个请求后，不会被立即挂起已等待请求的完成，即使请求不能立即得到满足，进程在等待期间可以继续执行其他任务，同时可能会以某种方式(轮询访问、回调等)定期检查请求状态或者等待结果的通知。

故事理解：张三找李四辅导c语言，张三打电话给李四叫他下来，但李四正在寝室中复习期末，电话挂断，李四在复习的期间，张三可以做其他的事情，并定期多次打电话给李四，询问是否复习完毕。

  1. 特点：

a.行为 -> 进程在等待期间可以执行其他任务；

b.触发方式 -> 可能通过编程的方式实现，如：轮询、回调等。

c.管理层面：在应用层通过编程实现。

d.效率与并发性：效率高，提高并发性和响应能力。

  1. 应用场景：需要高并发和响应能力的场景，如：在网络编程中，服务器同时处理多个客户端的请求。
#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<sys/types.h>
#include<sys/wait.h>
 
#define SIZE 5 

typedef void(*fun_t)(); //函数指针类型
 
fun_t task[SIZE]; //函数指针数组
  
void printlog()
{
    printf("this is a log print task\n");
}
  
void printnet()
{
     printf("this is a net task\n");
}
 
void printNPC()
{
    printf("this is a flush NPC task\n");
}                                                                                                                            
void Inittask()
{
    task[0] = printlog;
    task[1] = printnet; 
    task[2] = printNPC;
    task[3] = NULL;
}

void executeTask()
{
    for(int i = 0; task[i]; i++)
        task[i]();  //回调函数机制                                                        }
 
int main()
{
    Inittask();
    pid_t id = fork(); 
    if(id == 0) //子进程
    {
        int cnt = 2;
        while(cnt)
        {
            printf("I am a process, id:%d, ppid:%d\n", getpid(), getppid());             			sleep(1);
         cnt--;
         }
         exit(1); //子进程退出
      }
  
      int status = 0; //存储子进程退出状态
      while(1) //基于非阻塞轮询的访问
      {
        pid_t rid = waitpid(id, &status, WNOHANG); //非阻塞等待
        if(rid > 0) //调用成功，收集到了已经结束的子进程                                            {
          printf("wait success, status:%d\n", status);
          break;
        }
        else if(rid == 0) //调用成功，未收集到已经结束的子进程
        {
            printf("child is running, father do other thing!\n");
            printf("------------ Task begin ----------------\n");
            executeTask(); //等待期间，执行其他任务 
            printf("------------ Task end ----------------\n");
        }
        else //调用失败
        {
            perror("wait error\n");
            break;
        }
          
        sleep(1);
    }
    return 0;
}

3.4. 获取子进程

status不能简单的当作整形来看，可以当作位图看待，它有自己的格式，只研究status低16位比特位。

3.4.1. 位操作

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

int main()
{
    pid_t id = fork();
      
    if(id == 0) //子进程
    {
        int cnt = 5;
        while(cnt)
        {
            printf("child is running, id:%d, ppid:%d\n", getpid(), getppid());
            sleep(1);
            cnt--;
        }
        exit(1); //子进程退出
    }
  
    int status = 0; //存储子进程退出状态
    pid_t rid = waitpid(id, &status, 0); 
    if(rid > 0) //等待成功
        printf("wait success, status:%d, exit code:%d, exit sign:%d\n", status, (status>>8)&0xff, status&0x7f);   //位操作获取子进程的退出码、退出信号        
 
     return 0;
}

3.4.2. 宏

  1. WIFEXITED(status)：检查子进程是否正常退出。

如果子进程通过调用exit函数或main函数return返回而退出，则WIFEXITED返回非0值(真)-》正常退出；如果子进程是由于接收到信号而退出，则WIFEXITED返回0(假)-》异常退出。

  1. WEXITSTATUS(status)：只有当WIFEXITED为真时，接着才会使用WEXITSTATUS获取子进程的退出码。
#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<sys/types.h>
#include<sys/wait.h>

int main()
{
    pid_t id = fork();
      
    if(id == 0) //子进程
    {
        int cnt = 5;
        while(cnt)
        {
            printf("child is running, id:%d, ppid:%d\n", getpid(), getppid());
            sleep(1);
            cnt--;
        }
        exit(1); //子进程退出
    }
  
    int status = 0; //存储子进程退出状态
    pid_t rid = waitpid(id, &status, 0); 
    if(rid > 0) //等待成功
    {
        if(WIFEXITED(status)) //子进程正常退出
            printf("wait success, status:%d, exit code:%d\n", status, WEXITSTATUS(status)); //提取退出码 宏
        else  //子进程异常退出                                                      
            printf("child process error!\n");
      }
   
     return 0;
}

问题1：在父进程中定义两个全局变量(exit code、exit sign)，子进程修改exit code值，父进程可以获取到子进程的退出信息吗？

  • 不能。因为进程具有独立性，子进程对共享数据的修改，父进程是不可见的。

问题2：为什么要有wait、waitpid？

  • 为了避免子进程僵尸，造成内存泄漏，父进程需要通过wait、waitpid等函数来回收子进程资源，同时可以获取到子进程的退出信息。

  • 子进程的退出码、退出信号等内核数据，需要被拷贝到用户层的某个变量(如：wait、waitpid中的status参数等)，这个过程需要调用系统调用接口，因为用户空间的程序无法直接访问内核空间的数据。

4. 进程程序替换

4.1. 概念与原理

  1. 概念：它允许一个进程在执行期间，用一个新的程序来替换当前正常执行的程序，即：用全新的程序替换原有的程序。

这意味着进程在调用一种exec函数，当前进程的用户空间代码和数据被新程序的代码和数据完全替换(覆盖)，从新程序的启动例程开始执行。

💡Tips：调用exec函数，并不会创建新的进程，而是对原有进程的资源进行替换，因此调用exec前后该进程的pid并未发生改变。

  1. 原理：加载新程序 -> 替换当前程序 -> 更新页表 -> 执行新程序。

  • 加载新程序：当进程决定进行程序替换时(调用exec函数)，它会请求OS将全新程序(代码和数据)从磁盘中加载到内存。

  • 更新页表：为了实现替换，OS需要更新页表，将原来指向旧程序代码的虚拟地址映射到新程序代码的物理地址上，这样，就会执行新程序的代码。

  1. 所谓的把磁盘的数据加载到内存，把磁盘的数据拷贝到内存中，磁盘，内存都是硬件，只有操作系统具有将数据从一个硬件（磁盘）搬移到另一个硬件（内存）的能力，从而支持程序的加载和替换。

💡注意：进程替换的本质工作就是加载，充当的是加载器的角色！

4.2. 替换函数exec*

  1. l(list)：有l表示命令行参数采用列表；v(vector)：有v表示命令行参数采用数组；

  2. p(path)：有p自动去环境变量中搜索，允许只写程序名)；

  3. e(env)：有e表示设置全新的环境变量，需要自己维护。


int execl(const char* path，const char* arg，. . .)；

解释：以列表的形式传递命令行参数，最后必须以NULL结尾，第一个参数必须是程序的绝对路径。

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

int main()
{
    printf("I am a process\n");
  
    //以列表的形式传参(l); 命令行怎么写，参数怎么传(可变参数列表)，但结尾必须以NULL结尾
    execl("/usr/bin/ls", "ls", "-l", NULL);                                                                                  
    return 0;
}

int execv(const char* path，char* const argv[ ])；

解释：以数组的形式传递命令行参数，将命令行参数存储在以NULL指针结尾的指针数组中。

char* const argv[] = {(char*)"ls", (char*)"-l", NULL}; //存储命令行参数的以NULL结尾的指针数组
//以数组的形式传参(v)                                                                      
execv("/usr/bin/ls", argv);

int execlp(const char* file，const char* arg，. . .)；

int execvp(const char* file，char* const argv[ ])；

解释：第一个参数允许用户只提提供程序名，在替换时，自动去环境变量PATH指定的路径中查找程序。

char* const argv[] = {(char*)"ls", (char*)"-l", NULL}; //存储命令行参数的以NULL结尾的指针数组
//有p自动去环境PATH中搜索，允许第一个参数只写程序名                                   
execlp("bin", "ls", "-l", "NULL");
execvp("bin", argv);

int execle(const char* path，const char* arg，. . . ，char* const envp[ ])；

int execvpe(const char* file，char* const argv[ ]，char* const envp[ ])；

int execve(const char* filename，char* const argv[ ]，char* const envp[ ])；

解释：最后一个参数为自己维护的环境变量(可设置全新的环境变量表)。

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

int main()
{
    printf("I am a process\n");

    char* const env[] = {(char*)"haha=hehe", (char*)"zzx=lala", NULL}; //自己维护环境变量
    execle("./mytest", "-a", "-b", NULL, env); //设置全新的环境变量

    return 0;
}

#include<stdio.h>

int main(int argc, char* argv[], char* env[])
{
    for(int i = 0; argv[i]; i++)
        printf("argv[%d]:%s\n", i, argv[i]);
 
    for(int i = 0; env[i]; i++)
        printf("env[%d]:%s\n", i, env[i]);
 
    return 0;                                                                           
}

4.2.1. 细节

  1. 替换完成，不会创建新的进程。

  2. 程序一旦替换成功，exec*后续的代码不在执行。

  3. exec*函数只有出错的返回值，没有成功的返回值。

exec*函数调用失败，返回-1，并设置错误码以指示错误的原因。

  1. 进程替换本身不会改变环境变量的数据。

子进程会自动继承父进程的环境变量，子进程通过exec函数进行程序替换，加载并执行新的程序，这个新的程序会继承子进程所拥有的环境变量。

#include<stdio.h> 
int main()
{
    extern char** environ;
  
    for(int i = 0; environ[i]; i++)
        printf("%s\n", environ[i]);
    
    return 0;                                                                    
}

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

int main()  
{
    pid_t id = fork();
  
    if(id == 0)
    {
        execl("./mytest", "mytest", NULL);
        exit(0);
     }
 
    pid_t rid = waitpid(id, NULL, 0);
    if(rid > 0)
         printf("father wait success!\n");                                              
  
    return 0;
}
  1. int putenv(char* string)；
  • 功能：动态改变或新增环境变量。

如果指定的环境变量已经存在，那么它的值会被新的字符串中的值所替换；如果指定的环境变量不存在，那么它会被添加到环境变量表中。

4.3. 多进程版本替换

多进程版本替换通常设计到父进程创建子进程，然后子进程使用exec函数来替换其执行的程序。

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

int main()  
{
    pid_t id = fork();
  
    if(id == 0)
    {
        printf("I am a child process\n");
       execl("/usr/bin/ls", "ls", "-l", NULL);
         printf("程序替换成功\n");
        exit(0);
     }
 
    pid_t rid = waitpid(id, NULL, 0);
    if(rid > 0)
         printf("father wait success!\n");                                              
  
    return 0;
}

问题1：为什么子进程进行替换，父进程无任何影响？

  • 进程具有独立性：每个进程都有自己的地址空间，意味着每个进程只能访问自己的内存区域，而不能访问其他进程的内存区域，所以子进程进行程序替换，只会改变自己的地址空间的内容，不会影响到父进程的地址空间。

  • exec函数的行为：仅在调用它的进程中生效，而不会影响到父进程。由于exec函数是在子进程中调用的，因此只有子进程的映像被替换，父进程的映像保持不变，父进程继续执行其后续代码。

问题2：shell是如何执行起来一个指令的？

  • 读取命令行输入 -> 解析命令 -> 创建子进程 -> 执行程序替换 -> 等待子进程结束。

问题3：exec函数可以执行系统的指令(程序)，它可以执行我们自己编写的程序吗？

  • 可以。无论你使用什么编程语言(c++、python等)编写程序，只要该程序可以被编译或者解释成可执行格式，并且位于系统可以访问的路径中，你就可以通过shell使用exec函数来执行它。

💡Tips：.cc、.cpp、.cxx都是c++的后缀。

4.4. 应用场景

进程替换的应用场景有：Shell命令解释、服务器设计、在线OJ、搜索引擎等

  1. Shell命令解释：当用户在Shell中输入一个命令，Shell会创建一个子进程来执行该命令，这个子进程会使用exec函数来替换需执行命令的代码和数据，从而执行用户指定的程序。

  2. 服务器设计：在服务器程序中，父进程可以创建多个子程序来处理客户端的请求，每个子程序可以使用exec函数来执行特定的程序或者服务。

补充：在现代计算机系统中，内核数据结构主要使用的是物理地址，而虚拟地址是OS给用户提供的功能模块。虚拟地址到物理地址的转换是由操作系统和硬件协同完成的，而且这个转化规则相对简单。

奶芙c
关注
Linux操作系统编程(linux多线程的互斥与同步控制及实践)
02-11
Linux操作系统编程，主要提供高级编程技术及实践方面内容。主要侧重多线程互斥与同步控制程序设计、调试等。部分代码练习。
【Linux】解锁进程地址空间奥秘，高效环境变量的实战技巧
m0_74808907的博客
08-12 4767
一文带你由浅入深掌握环境变量、进程地址空间、页表！
“解锁进程间高效沟通，Linux IPC是你的关键钥匙！“#Linux系统编程之进程间通信【下】
CallmeBrotherMa的博客
08-26 470
欢迎踏入Linux系统编程之进程间通信【下篇】的广阔领域！本篇博文将带您深入探索共享内存的奥秘，从概述其基本概念到实战编程应用，让您全面掌握。随后，我们将转向信号的世界，全面阐述信号的基本概念，并通过编程实例展示如何利用信号进行进程间通信，更将深入探讨信号如何携带消息，并以直观简图辅助理解，实战演示信号携带消息的编程技巧。此外，信号量作为重要的同步机制也将被详细介绍，通过分两部分进行的实战编程教学，确保您能够熟练掌握其使用。
Linux系统下的多线程编程入门.pdf
12-20
在Linux系统下进行多线程编程是开发高效并发应用程序的关键技术之一。本文将深入探讨Linux环境中的多线程概念、创建与管理线程的方法、线程同步与通信机制，以及多线程编程中可能遇到的问题和解决策略。 一、多线程...
linux下的C\C++多进程多线程编程实例详解
09-15
### Linux下的C/C++多进程多线程编程实例详解 #### 一、多进程编程 在Linux环境下，多进程编程是实现并发处理的一种常见方法。通过`fork()`系统调用，我们可以创建一个新的进程，该进程几乎复制了父进程的所有属性...
Linux C 后台服务程序单进程控制的实现
09-14
在Linux系统中，后台服务程序通常需要以单进程模式运行，以确保系统资源的有效管理和避免冲突。本篇文章将深入探讨如何使用C语言实现Linux后台服务程序的单进程控制，通过示例代码帮助读者理解相关机制。 首先，...
Linux的多线程编程的高效开发经验
09-14
在Linux系统中，多线程编程是通过Pthread库实现的，这个库为开发者提供了丰富的API来处理线程、互斥锁和条件变量等概念。线程是程序执行的独立路径，互斥锁用于保护共享资源，防止并发访问引发的问题，而条件变量则...
plc控制系统如何解锁
07-17
PLC（Programmable Logic Controller，可编程逻辑控制器）控制系统是现代工业自动化中重要的组成部分，它通过编程控制各种设备和过程，如机械设备、生产流程等。在特定情况下，需要对PLC系统进行解锁操作，以便进行...
linux 网络序
CodeHouse的博客
09-30 501
在将ip字符串转网络序存储时。根据整形二进制显示判断。
Linux 再入门整理：详解 /etc/fstab 文件
一只奋斗的猪
10-01 1299
`/etc/fstab` 文件是 Linux 系统中用于定义和管理文件系统的挂载信息的配置文件。它的作用是告诉系统在启动时，应该如何自动挂载各种文件系统。挂载是 Linux 操作系统中一种将存储设备与目录树关联的操作。通过挂载，存储设备中的文件可以通过目录访问。
Linux 性能优化之CPU 多级缓存
山河已无恙
09-30 1070
博文内容为 Linux CPU 多级缓存认知内容涉及：什么是CPU多级缓存认知，CPU 硬件缓存信息，缓存流程写入策略，映射算法认知CPU 缓存分析，使用 valgring 和 Perf 分析CPU 缓存命中情况编码方面 CPU 缓存优化，数据指令缓存，多核缓存命中率优化方式理解不足小伙伴帮忙指正 😃,生活加油哦99%的焦虑都来自于虚度时间和没有好好做事，所以唯一的解决办法就是行动起来，认真做完事情，战胜焦虑，战胜那些心里空荡荡的时刻，而不是选择逃避。
在 Kali Linux 中安装 Impacket
weixin_44023460的博客
09-30 420
在安装 Impacket 之前，你需要确保安装了 Python 和一些必要的依赖。通常，Kali 已经预装了 Python。步骤 3：克隆 Impacket 仓库。步骤 4：进入 Impacket 目录。如果你看到帮助信息，说明安装成功。步骤 5：安装 Impacket。
Linux的基本指令（2）
shylyly_的博客
10-01 1051
Linux的基本指令（2） man nano cp mv which 自制指令 alias echo cat tac > >> < more less head tail |（管道）
使用Python实现在 Linux 和 Windows 之间的双向文件传输
2301_80892630的博客
09-29 732
在 Linux 和 Windows 之间可以用python程序实现双向文件传输，通过创建一个简单的文件传输程序来实现。该程序将使用套接字socket通信，允许任意一端发送或接收文件。这是在我的那篇实现python两个进程之间相互通信的基础上拓展的（不过只看这一篇文章也行），那篇文章传输的数据是字符串类型，今天我来实现文件的传输。
linux之curl
最新发布
qq_41081716的博客
10-06 328
发送指定的数据作为POST请求的主体。数据可以是键值对的形式。： 添加自定义HTTP头部。可以多次使用以添加多个头部。： 用于发送表单数据，特别是文件上传。： 指定请求方法，例如。
Linux下send函数和recv函数
威桑的博客
10-01 498
Linux下send和recv
第五章 linux实战-黑链
a666666688的博客
09-29 617
代码分析 2.webshell的绝对路径 flag{xxxx/xxx/xxx/xxx/} 下载html文件夹 3.黑客注入黑链文件的 md5 md5sum file flag{md5} 打开可疑文件所在位置 代码分析 4.攻击入口是哪里？url请求路径，最后面加/ flag{/xxxx.xxx/xxxx/x/} wireshark分析pacp文件 代码分析
第五章 linux实战-挖矿 二
a666666688的博客
09-29 438
未发现keys进入.ssh，查看信息发现keys，并查看其信息。最近改动的前十个文件。
LinuxO(1)调度算法
2301_78131481的博客
10-05 917
在Linux中，O(1)调度算法是一种进程调度算法。O(1)表示算法的时间复杂度是常数级别的，与系统中的进程数量无关。
Linux系统编程：基于中间件的进程间锁解析
在Linux系统编程中，线程同步是一个至关重要的概念，特别是在处理高频率的金融交易数据接收时。进程间锁，即pthread_mutex，是实现多线程之间同步的一种机制，确保对共享资源的访问是互斥的，防止数据竞争问题。在...
评论 109
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值