C语言进程的相关操作

最新推荐文章于 2024-10-16 22:25:37 发布
最新推荐文章于 2024-10-16 22:25:37 发布
阅读量604 收藏 1
点赞数 1
分类专栏： unix_c 文章标签： c语言 linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lubuhan/article/details/133375392
版权

C语言进程的相关操作

进程简介

  • 每个进程都有一个非负整数形式到的唯一编号，即PID（Process Identification，进程标识）
  • PID在任何时刻都是唯一的，但是可以重用，当进程终止并被回收以后，其PID就可以为其他进程使用
  • 进程的PID由系统内核根据延迟重用算法生成，以确保新进程的PID不同于最近终止进程到的PID
  • 其中0号进程，叫做交换进程，系统内核中的一部分，所有进程的根进程，磁盘上没有它的可执行文件
  • 1号进程是init进程，在系统自举过程结束时由调度进程创建，读写与系统相关的初始化文件，引导系统至一个特定状态，以超级用户特权运行的普通进程，永不终止
  • 除去调度进程以外，系统中的每个进程都有一个唯一的父进程，对任何一个子进程而言，其父进程的PID即是它的PPID
  • 下面这些函数都包含在unistd.h头文件中
  • pid_t getpid(void);返回调用进程的PID
  • pid_t getppid(void);返回调用进程的父进程的PID
  • uid_t getuid(void);返回调用进程的实际用户ID
  • gid_t getgid(void);返回调用进程的实际组ID
  • uid_t geteuid(void);返回调用进程的有效用户ID
  • gid_t getegid(void);返回调用进程的有效组ID

创建子进程

  • 创建子进程的函数包含在unistd.h头文件中

  • fork函数

    • pid_t fork(void);
      • 功能：创建调用进程的子进程
      • 返回值：失败返回-1，成功情况下返回的变量在父进程中是PID，在子进程中是0
      • 可以通过这个返回值来执行父进程和子进程
      • 当系统中的总的线程数达到了上限，或者用户的总进程达到了上限，fork函数会失败。

  • 创建子进程示例代码

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

int main(void)
{
    printf("haha\n");
    // 创建子进程
    int pid = fork();
    printf("heihei\n");
    return 0;
}

/*
haha
heihei
heihei
*/

父子进程间的关系

  • 以下是父子进程中数据相关copy的示例图
    在这里插入图片描述

  • 验证上图

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


int global = 100;  // 父进程全局变量->数据区

int main(void)
{
int local = 200;  // 父进程局部变量->栈区
int *heap = malloc(sizeof(int));  // 动态分配内存->堆区
*heap = 3;

printf("父进程第一次打印: PID->%d %p->%d %p->%d %p->%d\n", getpid(), &global, global, &local, local, heap, *heap);
// 创建子进程
pid_t pid = fork();
if(pid == 0)
{
// 子进程操作，数据会从父进程copy一份过来，这里执行++操作
printf("子进程打印: PID->%d PPID->%d %p->%d %p->%d %p->%d\n", getpid(), getppid(), &global, ++global, &local, ++local, heap, ++*heap);
return 0;
}
sleep(1);  // 这里等1s，让子进程++
printf("父进程第二次打印: PID->%d %p->%d %p->%d %p->%d\n", getpid(), &global, global, &local, local, heap, *heap);

return 0;
}

/*
父进程第一次打印: PID->1674604 0x5577e1acc010->100 0x7ffd4d4bfaa8->200 0x5577e23422a0->3
子进程打印: PID->1674605 PPID->1674604 0x5577e1acc010->101 0x7ffd4d4bfaa8->201 0x5577e23422a0->4
父进程第二次打印: PID->1674604 0x5577e1acc010->100 0x7ffd4d4bfaa8->200 0x5577e23422a0->3

这里的父进程和子进程地址一样是虚拟地址里面一样，因为每个进程都有一个独立的虚拟地址池，相互不影响的
发现子进程跟父进程互相不影响，验证了上图的案例
*/

  • 父子进程操作文件，其实是共享一个文件表项的
    在这里插入图片描述

  • 验证上图

    #include <stdio.h>
#include <string.h>
#include <fcntl.h>
#include <unistd.h>
#include <time.h>

int main(void)
{
    // 父进程打开文件
    int fd = open("./test.txt", O_WRONLY | O_CREAT | O_TRUNC, 0664);
    if(fd == -1)
    {
        perror("open");
        return -1;
    }

    // 父进程写入数据
    char *data = "hello bhlu!";
    if(write(fd, data, strlen(data)) == -1)
    {
        perror("write");
        return -1;
    }

    // 创建子进程
    pid_t pid = fork();
    if(pid == 0)
    {
        // 子进程修改文件读写位置
        if(lseek(fd, -5, SEEK_END) == -1)
        {
            perror("lseek");
            return -1;
        }
        return 0;
    }

    // 再次插入数据，验证子进程修改的读写位置是否生效
    sleep(1);  // 先等1s，让子进程执行完
    data = "linux\n";
    if(write(fd, data, strlen(data)) == -1)
    {
        perror("write");
        return -1;
    }

    // 关闭文件
    close(fd);
    return 0;
}

/*
cat test.txt
hello linux
发现是修改成功的，说明上图是对的，子进程和父进程共用一个文件表项
*/

进程的终止

以下内容只是简单的介绍进程的终止，以便理解

  • 进程的终止分为两种

    1. 正常终止：分为三种情况

      1. main函数中正常返回

      2. 使用exit函数终止：exit函数可以在任何函数中执行令进程结束，return语句只有在main函数中执行才能令进程结束

        #include <stdlib.h>

void exit(int status);
/* 
功能: 令进程终止
参数: status 进程的退出码，相当于main函数的返回值
无返回值
*/

/*
exit函数在终止前会做以下几件收尾工作
1. 调用实现通过atexit或on_exit函数注册的函数退出函数
2. 冲刷并关闭所有仍处于打开状态的标准I/O流
3. 删除所有通过tmpfile函数创建的临时文件
4. 执行_exit(status);
使用exit函数令进程终止，通常使用EXIT_SUCCESS和EXIT_FAILUR两个宏
EXIT_SUCCESS -> 1; EXIT_FAILUR -> 0;
*/

      3. 调用_exit/_Exit函数令进程终止

        // _exit函数
#include <unistd.h>

void _exit(int status);
/*
参数: status 进程的退出码，相当于main函数的返回值
无返回值
*/

// _Exit函数
#include <stdlib.h>

void _Exit(int status);
/*
参数: status 进程的退出码，相当于main函数的返回值
无返回值
*/

/*
_exit函数在终止前会做以下几件收尾工作
1. 关闭所有仍处于打开状态的文件描述符
2. 将调用进程的所有子进程托付过init进程
3. 向调用进程的父进程发送SIGCHLD(7)信号
4. 令调用进程终止运行，将status的低八位作为退出码保存在其终止状态中
*/

    2. 异常终止

      1. 进程执行了系统认为具有危险性的操作时，或者系统本身发生故障或意外，内核会向进程发送特定的信号

        SIGILL(4) -> 进程试图执行非法指令
SIGBUS(7) -> 硬件或对齐错误
SIGEPE(8) -> 浮点异常
SIGSEGV(11) -> 无效内存访问
SIGPWR(30) -> 系统供电不足

      2. 人为触发信号

        SIGINT(2) -> Ctrl+c
SIGQUIT(3) -> Ctrl+\
SIGKILL(9) -> 不能被捕获或忽略的进程终止信号
SIGTERM(15) -> 可以被捕获或忽略的进程终止编号

      3. 向进程自己发送信号

        #include <stdlib.h>

void abort(void);
/*
功能: 想进城发送SIGABRT(6)信号，该信号默认情况下可以使进程结束
无返回值
*/

在使用exit函数或main函数正常退出时，如果注册了atexit或on_exit，那就会触发退出函数，以下是示例代码

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

void func(void)
{
    exit(6);
}

void goto1(void)
{
    printf("goto1\n");
}

void goto2(int status, void *arg)
{
    printf("status = %d\n", status);
    printf("arg = %s\n", (char *)arg);
}

int main(void)
{
    atexit(goto1);  // 退出之前执行goto1
    on_exit(goto2, "heihei");  // 退出之前执行goto2，可以传参
    func();
    return 0;
}

/*
相当于钩子函数，在退出之前执行，可以进行一些回收操作
status = 6
arg = heihei
goto1
*/

回收子进程

  • 如果不回收子进程的话，会导致有很多僵尸进程的存在，从而消耗更多的系统资源。
  • 父进程需要等待子进程到的终止，以继续后续工作
  • 父进程需要了解子进程终止的原因，是正常终止，还是异常终止

阻塞回收

  • wait函数是用于回收子进程的一个函数，它使用的是阻塞回收，使用它必须包含sys/wait.h头文件

  • wait函数

    • pid_t wait(int *status);

      • 功能：等待和回收任意子进程

      • 参数：status用于输出子进程的终止状态，可置NULL

        • 补充：可以使用以下工具宏分析子进程的终止状态

          if(WIFEXITED(status))
    // 真
    printf("正常终止: 进程退出码是%d\n", WEXITSTATUS(status));
else
    // 假
    printf("异常终止: 终止进程的信号是%d\n", WTERMSIG(status));

// 下面跟上面判断条件相反
if(WIFSIGNALED(status))
    // 真
    printf("异常终止: 终止进程的信号是%d\n", WTERMSIG(status));
else
    // 假
    printf("正常终止: 进程退出码是%d\n", WEXITSTATUS(status));

      • 返回值：成功返回回收的子进程PID，失败返回-1

  • 简单代码示例

    // 子进程的回收
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/wait.h>

int main(void)
{
    // 创建子进程
    pid_t pid = fork();
    if(pid == -1)
    {
        perror("fork");
        return -1;
    }
    // 子进程相关操作
    if(pid == 0)
    {
        printf("%d进程: 我是子进程!\n", getpid());
        // sleep(5);
        // exit(3);
        // _exit(5);
        // return 2;
        // abort();  // 向进程发送信号异常结束
        // 以下两句会造成内存无效访问，会返回11
        char *p = NULL;
        *p = 123;
    }
    // 父进程等待回收子进程
    printf("%d进程: 我是父进程!\n", getpid());
    int s;  // 用来输出所回收的子进程终止状态
    pid_t childpid = wait(&s);
    if(childpid == -1)
    {
        perror("wait");
        return -1;
    }
    printf("父进程回收了%d进程的僵尸!\n", childpid);
    // 根据返回值判断子进程是否是正常结束
    if(WIFEXITED(s))
        printf("正常结束: %d\n", WEXITSTATUS(s));
    else
        printf("异常结束: %d\n", WTERMSIG(s));

    return 0;
}

  • 以下代码是一个循环创建5个进程，然后父进程挨个回收

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

int main(void)
{
    printf("%d进程: 我是父进程!\n--------------------------\n", getpid());
    sleep(1);
    // 创建子进程
    for(int i = 0; i < 5; i++)
    {
        pid_t pid = fork();
        if(pid == -1)
        {
            perror("fork");
            return -1;
        }
        // 子进程操作
        if(pid == 0)
        {
            printf("%d进程: 我是子进程!\n", getpid());
            sleep(i+1);
            return i+1;
        }
    }
    
    // 父进程操作: 回收子进程
    while(1)
    {
        int s;  // 用户接收子进程的终止状态
        pid_t childpid = wait(&s);
        if(childpid == -1)
        {
            if(errno == ECHILD)
            {
                printf("没有子进程可以回收了!\n");
                break;
            }
            else
            {
                perror("wait");
                return -1;
            }
        }
        // 判断子进程的终止状态
        if(WIFEXITED(s))
            printf("正常结束: %d\n", WEXITSTATUS(s));
        else
            printf("异常终止: %d\n", WTERMSIG(s));
    }
    return 0;
}

非阻塞回收

  • waitpid函数一般用于非阻塞回收子进程，还可以回收特定子进程，使用这个函数需要引用sys/wait.h头文件

  • waitpid函数

    • pid_t waitpid(pid_t pid, int *status, int options);
      • 功能：等待并回收任意或特定子进程
      • 参数
        • pid：取-1等待并回收任意子进程，相当于wait函数，>0等待回收特定子进程
        • status：用于输出子进程的终止状态，可置NULL
        • option：0代表阻塞模式，WNOHANG代表非阻塞模式，如果等待的进程还在运行，则返回0
      • 返回值：成功返回回收子进程的PID或者0，失败返回-1

  • 以下是使用非阻塞回收的方法回收子进程

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

int main(void)
{
    printf("%d进程: 我是父进程!\n-------------------------\n", getpid());
    // 创建子进程
    for(int i = 0; i < 5; i++)
    {
        pid_t pid = fork();
        if(pid == -1)
        {
            perror("fork");
            return -1;
        }
        // 子进程相关操作
        if(pid == 0)
        {
            printf("%d进程: 我是子进程!\n", getpid());
            sleep(i+1);
            // 三种效果
            if(i == 3)
            {
                abort();
            }
            else if(i == 4)
            {
                char *p = NULL;
                *p = 123;
            }
            else
            {
                return i+1;
            }
        }
    }
    
    // 父进程回收子进程
    sleep(1);
    while(1)
    {
        int s; // 用于保存进程的终止状态
        pid_t childpid = waitpid(-1, &s, WNOHANG);  // 这里使用的是非阻塞模式
        if(childpid == -1)
        {
            // 报错或者没有子进程了
            if(errno == ECHILD)
            {
                printf("没有子进程了!\n");
                break;
            }
            else
            {
                perror("waitpid");
                return -1;
            }
        }
        else if(childpid == 0)
        {
            // 子进程还在运行
            printf("子进程在运行，无法回收，先睡会!\n");
            sleep(2);
        }
        else
        {
            // 回收成功并判断是否正常终止
            printf("%d子进程回收成功!\n", childpid);
            if(WIFEXITED(s))
                printf("%d进程正常终止, 进程退出码: %d\n\n", childpid, WEXITSTATUS(s));
            else
                printf("%d进程异常终止, 终止进程信号: %d\n\n", childpid, WTERMSIG(s));
        }
    }
    return 0;
}

/*
代码执行效果
1761797进程: 我是父进程!
-------------------------
1761798进程: 我是子进程!
1761799进程: 我是子进程!
1761800进程: 我是子进程!
1761801进程: 我是子进程!
1761802进程: 我是子进程!
子进程在运行，无法回收，先睡会!
1761798子进程回收成功!
1761798进程正常终止, 进程退出码: 1

1761799子进程回收成功!
1761799进程正常终止, 进程退出码: 2

子进程在运行，无法回收，先睡会!
1761800子进程回收成功!
1761800进程正常终止, 进程退出码: 3

1761801子进程回收成功!
1761801进程异常终止, 终止进程信号: 6

子进程在运行，无法回收，先睡会!
1761802子进程回收成功!
1761802进程异常终止, 终止进程信号: 11

没有子进程了!
*/

补充

  • 实际情况下，无论进程是正常终止还是异常终止，都会通过系统内核向其父进程发送一个SIGCHLD(17)信号，我们可以提供一个针对该信号的处理函数，在信号处理函数中异步的方式回收子进程，这样不仅流程简单，回收效率还高，僵尸进程的存活时间也会很短。

创建新进程

与fork函数不同，这里使用的exec函数是创建一个新的进程，新进程会取代调用自身的进程，新进程覆盖之前的进程地址空间，进程的PID不会改变。
在这里插入图片描述

  • exec不是一个函数，而是一堆函数，功能一样，用法相似

  • #include <unistd.h>

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

      execl("/bin/ls", "ls", "-a", "-l", NULL);
/*
path使用的是路径名
使用NULL作为arg的结尾
失败返回-1，成功不返回
*/

    2. int execlp(const char *file, const char *arg, ...);

      execlp("ls", "ls", "-a", "-l", NULL);
/*
file使用的是文件名，会从环境变量中一个个的找
使用NULL作为arg的结尾
失败返回-1，成功不返回
*/

    3. int execle(const char *path, const char *arg, ..., char *const envp[]);

      char *envp[] = {"NAME=bhlu", "AGE=25", NULL};
execle("/usr/bin/env", "env", NULL, envp);
/*
比excel多一个envp，用于设置环境变量，它设置什么，新进程的环境变量就只有什么
失败返回-1，成功不返回
环境变量输出:
    NAME=bhlu
    AGE=25
*/

    4. int execv(const char *path, char *const argv[]);

      char *argv[] = {"ls", "-a", "-l", NULL};
execv("/bin/ls", argv);
/*
execv系列使用的都是字符指针数组，字符数组是以NULL结尾
失败返回-1，成功不返回
*/

    5. int execvp(const char *file, char *const argv[]);

      char *argv[] = {"ls", "-a", "-l", NULL};
execvp("ls", argv);
/*
跟execv差不多，就第一个参数是文件名
失败返回-1，成功不返回
*/

    6. int execve(const char *path, char *const argv[], char *const envp[]);

      char *argv[] = {"env", NULL};
char *envp[] = {"NAME=bhlu", "AGE=25", NULL};
execve("/usr/bin/env", argv, envp);
/*
跟execle函数差不多，就是这里的第二个参数是字符指针数组
失败返回-1，成功不返回
*/

  • 后缀不同，代码的含义也不同

    • l：即list，新进程的命令以字符指针列表形式传入，列表以空指针结束
    • p：即path：第一个参数，不包含/，就根据PATH环境变量搜索文件
    • e：即environment：设定环境变量，不指定则从调用进程复制
    • v：即vector：新进程的命令行参数以字符指针数组的形式传入，数组以空指针结束
    • 实际底层最后使用的都是execve函数

  • 使用exec函数基本会将原进程的所有信号、属性、数据等都丢失或者恢复初识状态，只有PID、PPID、UID等会被继承下来。

  • 一般都会先创建一个子进程，然后在子进程中使用exec函数，以下是相关示例

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

int main(void)
{
    // 创建子进程
    pid_t pid = fork();
    if(pid == -1)
    {
        perror("fork");
        return -1;
    }

    // 子进程相关操作
    if(pid == 0)
    {
        char *argv[] = {"env", NULL};
        if(execvp("/bin/env", argv) == -1)
        {
            perror("execvp");
            return -1;
        }
    }

    // 父进程操作
    printf("父进程PID: %d\n", getpid());
    return 0;
}

system

  • 下面介绍的是c语言执行shell命令的函数

  • #include <stdlib.h>

    • int system(const char *command);
      • 功能：执行shell命令
      • 参数：shell命令，如果参数取NULL，返回非0表示Shell可用，返回0表示不可用
      • 返回值：成功返回command进程的终止状态， 失败返回-1

  • 代码实例

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

int main(void)
{
    int s = system("echo $PATH");
    if(s == -1)
    {
        perror("system");
        return -1;
    }

    printf("父进程PID: %d\n", getpid());
    return 0;
}

  • system函数内部调用了vfork、exec和waitpid等函数，而且它是标准库函数，可以跨平台使用

    • 如果调用vfork或waitpid函数出错，则返回-1
    • 如果调用exec函数出错，则在子进程中执行exit(127)
    • 如果都成功，会从waitpid获取command进程的终止状态
bhlu
关注
专栏目录
C语言“进程“相关概念
weixin_41454263的博客
10-25 822
程序是静态的，它是一些保存在磁盘上的指令的有序集合。进程是动态的，是指程序的运行过程。每个进程都有独立的，进程是资源分配的最小单位。当一个被创建后，内存会开辟4G的空间，其分为：3G的PCB内核空间（必须通过系统调用才能访问）和1G的用户空间（堆区、栈区、代码段、数据段）。
C语言中操作进程信号的相关函数使用详解
01-01
C语言signal()函数：设置信号处理方式 头文件： #include 定义函数： void (*signal(int signum, void(* handler)(int)))(int); 函数说明：signal()会依参数signum 指定的信号编号来设置该信号的处理函数. 当...
C语言 操作系统 进程控制
li1441853031的博客
07-01 5754
一、进程控制 ●基本要求：模拟操作系统内核对进程的控制和管理：包括进程的创建和撤 销、进程状态的切换和简单的内存空间管理。 内容 模拟触发进程状态转换的事件：采用键盘控制方法来模拟触发进程状态切换的事件（例如输入 1 代表创建新进程、2 执行进程时间片到、3 阻塞 执行进程、4 唤醒第一个阻塞进程、5 终止执行进程），实现对应的控制程序。 数据结构 定义管理每个进程的数据结构 PCB：包含进程名称、队列指针、分配的物理内存区域（基址和长度）。每创建一个进程时，需要为其创建 PCB 并 分配空 闲内存空间，对
C语言进程——基础
Stars____的博客
04-25 6566
什么是进程 什么是程序 一组可以被计算机直接识别的 有序 指令 的集合。 通俗讲：C语言编译后生成的可执行文件就是一个程序。 那么程序是静态还是动态的？ 程序是可以被存储在磁盘上的，所以程序是静态的。 那什么是进程 进程是程序的执行过程，是动态的，随着程序的使用被创建，随着程序的结束而消亡。 可以说进程是一个独立的可调度的任务。 进程是程序执行的最小单位。 进程是资源(内存资源)管理的最小单位。 一个程序可以只有一个进程，此时正在运行的这个程序也叫进程。 一个程序也可以有多个进程，此时正在运行的这个程序
C语言-进程-线程
qq_33406021的博客
05-06 1046
USER: 启动这些进程的用户PID: 进程的ID%CPU 进程占用的CPU百分比；%MEM 占用内存的百分比；VSZ：进程占用的虚拟内存大小（单位：KB）RSS：进程占用的物理内存大小（单位：KB）
c语言进程操作函数,C语言中进程信号集的相关操作函数详解
weixin_30030255的博客
05-21 97
2015C语言sigismember()函数：测试某个信号是否已加入至信号头文件：#include 定义函数：int sigismember(const sigset_t *set, int signum);函数说明：sigismember()用来测试参数signum 代表的信号是否已加入至参数set 信号集里. 如果信号集里已有该信号则返回1, 否则返回0.返回值：信号集已有该信号则返回1, 没...
操作系统——进程调度 C语言版
li1441853031的博客
07-01 3396
先来先服务FCFS算法：进程先进入的先服务。 短作业优先SJF算法：根据当前到来的进程，筛选当前所有进程中所需运行时间最短的进程。 时间片轮转算法：根据时间片的大小，切换进程，直到每个进程都运行完成。 计算出每个进程的开始时间，结束时间，周转时间T=开始时间-到达时间，带权周转时间W = T/运行时间，平均周转时间，平均带权周转时间。 #include <stdio.h> #include <stdlib.h> #include<string.h> typedef str
【C语言】进程和线程详解
EleganceJiaBao的博客
08-19 1612
进程和线程是操作系统中实现并发执行的两种主要方式，各有优缺点和适用场景。通过理解它们的基本概念和特点，以及掌握相关的编程技巧和同步机制，可以编写出高效的并发程序，充分利用多核处理器的计算能力。
C语言守护进程代码
qq_31532979的博客
02-27 505
子进程注册了一个信号处理函数，当接收到SIGTERM信号时，调用exit()函数退出守护进程。SIGTERM是一个终止进程的信号，通常由操作系统或其他进程发送给进程，用于要求进程自行终止。通过注册信号处理函数，守护进程可以在接收到终止信号时做一些清理工作并正常退出。总而言之，这段代码实现了创建一个守护进程的过程，包括创建子进程、设置会话、重定向文件描述符和注册信号处理函数。守护进程的作用是在后台运行，并且独立于用户登录会话，通常用于长期运行的服务或后台任务。
操作系统进程调度算法（c语言模拟实现）
luming的博客
10-26 4929
本文旨在分享如何使用c语言对操作系统中的进程调度算法进行模拟实现
Linux使用C语言获取进程信息
Once_day的回忆
02-23 1838
在计算机的世界里，Linux进程是一个非常基础而且关键的概念。它可以被理解为正在执行的一个程序的实例。每个进程都有自己独特的身份，我们称之为进程ID（PID），就像每个人都有自己的身份证号码一样。Linux操作系统是一种多任务操作系统，可以同时运行多个进程，就像一个杂技团队能同时上演多个节目一样。现在，想象一下进程是厨房里的一个厨师，而计算机资源（如CPU、内存）则是厨房里的炉子、锅碗瓢盆。每个厨师都需要这些资源来完成他们的烹饪任务。
操作系统进程管理实验（C语言实现）
02-02
本实验以C语言为工具，旨在帮助学生深入理解操作系统中的进程管理机制。 首先，我们要理解什么是进程。在操作系统中，进程是程序的一次执行实例，它包含了程序的内存映像、打开的文件、分配的资源以及当前状态等。...
C语言中进程信号集的相关操作函数详解
01-01
C语言sigismember()函数：测试某个信号是否已加入至信号 头文件：#include 定义函数：int sigismember(const sigset_t *set, int signum); 函数说明：sigismember()用来测试参数signum 代表的信号是否已加入至参数...
详解C语言进程同步机制
12-17
进程同步是操作系统中确保...总之，C语言进程同步机制是操作系统中至关重要的组成部分，它确保了进程的并发执行不会引发数据不一致或系统崩溃。通过理解和应用这些同步机制，开发者可以编写出高效、可靠的多线程程序。
操作系统使用C语言链表实现进程管理
03-15
用C语言链表实现进程转换，阻塞变就绪，就绪变执行，执行变阻塞三种状态的转换
Educational Codeforces Round 170 (Rated for Div. 2) C. New Game（单调队列/滑动窗口）
puzhaoyu的博客
10-16 364
且同时又没有连续，那么连续的这个条件可能会被忽略。第一次提交超时了，可能是因为使用unordered_map存在较多冲突，所以改成map就很稳定了。由于数据是无序，且需要找非递减，所以可以排序，但是我们又不想保留太多相同数字，于是先哈希计数，再把键值对存储到一个数组里，再排序，排序方法是根据。的大小排序，然后使用两个限制条件的滑动窗口，如果条件符合，则扩大窗口（r++），如果超过。要注意的是，因为要求连续非递减的条件比较严格，要先判断，如果长度超过。则缩小窗口（l++），如果数字不连续，l直接跳到r处。
【C语言】--数组
weixin_74837455的博客
10-13 1078
😊个人主页: 起名字真南 😋个人专栏:【数据结构初阶】 【C语言】 【C++】 数组是一组相同类型元素的集合 ：一维数组创建的基本语法如下： 存放在数组中的值被称为数组元素，数组在创建的时候可以指定数组的大小和数组的元素类型。比如我们想创建某个班级里面10个学生的成绩，我们可以创建如下数组： 2.2 数组的初始化 2.3 数组类型 数组算是一种自定义类型，去掉数组名剩下的就是数组类型 arr1 的数组类型就是 int [5] ch 的数组类型就是 char [6] 在C语言中提供了一个 [] 操作符
Ascend C算子性能优化实用技巧04——Tiling优化
m0_71340392的博客
10-10 1164
什么是Tiling简介Ascend C是CANN针对算子开发场景推出的编程语言，原生支持C和C++标准规范，兼具开发效率和运行性能。使用Ascend C，开发者可以基于昇腾AI硬件，高效的实现自定义的创新算法。目前已经有越来越多的开发者使用Ascend C，我们将通过几期“Ascend C算子性能优化”专题分享，围绕开发者最为关心的算子性能优化环节，介绍Ascend C算子常用的优化技巧，帮助开发者自主构建出更优性能的算子。
Linux介绍及常用命令
最新发布
小旺的博客
10-16 644
1969 年，AT&T 公司的⻉尔实验室P MIT 合作开发的 Unix，í在于创建⼀个⽤于⼤型、并⾏、多⽤户的操作系统Unix 的推⼴：从学校⾛进企业Unix 的版本要两个：AT&T System V ——就是俗称的 系统 5linux是一种操作系统1991 年，芬兰赫尔⾟基⼤学的学⽣ Linus Torvals 为了能在家⾥的 PC 机上使⽤与学校⼀的操作系统，开始编写了类 UNIX.
C语言实现进程同步操作系统实验
"这是一个关于操作系统进程同步的C语言实验，主要涉及Windows系统下的信号量机制。实验中包含生产者（Producer）和消费者（Consumer）两个角色，使用了Semaphore类型的信号量g_semBuffer、g_semProduct以及互斥锁g_...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值