12.OS操作系统学习_进程空间与控制

最新推荐文章于 2024-07-17 21:40:42 发布
最新推荐文章于 2024-07-17 21:40:42 发布
阅读量283 收藏 4
点赞数 6
分类专栏： Linux02 文章标签： 学习 linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lakmiy/article/details/139095529
版权

12.OS操作系统学习:进程空间与控制

1.内存中的进程

我们思考

多进程运行，如何更好的区分空间？

写时拷贝机制原理是什么呢？

我们先来看一下这个学习到的图像:内存中的进程image

利用fork()函数创建子进程，使子进程和父进程共同使用一个变量。

#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <stdlib.h>
#include <sys/wait.h>
int main()
{
  int val = 10;
  pid_t id = fork();
  if(id == 0)
  {
  	val *= 2;	//刻意改变共享值
    printf("我是子进程，pid:%d ppid:%d 共享值:%d 共享值地址:%p\n", getpid(), getppid(), val, &val);
    exit(0);
  }

  waitpid(id, 0, 0);

  printf("我是父进程，pid:%d ppid:%d 共享值:%d 共享值地址:%p\n", getpid(), getppid(), val, &val);
  return 0;
}

image

现象:会发现同一个地址，出现了两个不同的value。

**解释:1.**引出逻辑地址:面向程序的地址，从0开始编址，每一条指令的逻辑地址就是与第一条指令之间的相对偏移。对于面向程序的地址，用户无法看到真实的绝对地址(物理地址)，他们是由os统一管理的。

2.真实的物理空间不是相同的

3.发生了写时拷贝机制

2.虚拟地址和物理地址的转换

虚拟空间通过notebook和MMU进行转换为真实的空间

2.1先来看MMU:

image

2.2再来看页表

页表 本质上就是一张表，操作系统 会为每个 进程 分配一个 页表，该 页表 使用 物理地址 存储。当 进程 使用类似 malloc 等需要 映射代码或数据 的操作时，操作系统 会在随后马上 修改页表 以加入新的 物理内存。当 进程 完成退出时，内核会将相关的页表项删除掉，以便分配给新的 进程。

2.3转换

image

image

解释:

  1. 其实操作系统通过页表映射发现val的值是共享的,但是进程具有独立性

  2. 操作系统 为 保证进程独立性,当任何一方对共享数据进行写=修改的时候,操作系统会在真的物理空间上开辟一块新的内存空间.

  3. 先拷贝数据,然后再修改映射关系,更改页表映射,然后再让进程进行修改.

  4. 所以这里的显示的地址是虚拟地址,也是相同的.

2.4 写时拷贝

定义:在数据第一次写入到某个存储位置时，首先将原有内容拷贝出来，写到另一位置处，然后再将数据写入到存储设备中，该技术只拷贝在拷贝初始化开始之后修改过的数据。

这里的写时拷贝是操作系统先进性数据拷贝,更改页表映射,然后再让进程进行修改.

3.为什么存在进程空间?

1.进程地址空间保证了数据的安全性

:::
每个进程都有进程地址空间，所有的进程都要通过页表映射到物理内存，如果进程直接访问物理内存，万一进程越界非法访问、非法读写时，页表就可以进行拦截，而且直接访问物理内存对于账号信息是非常不安全的，所以保证了内存数据的安全性
:::

2.地址空间的存在，可以更方便的进行进程和进程的数据代码的解耦，保证了进程独立性的特征

:::
对于进程而言，都有独立的地址空间及页表，通过页表映射到不同的物理内存上，所以一个进程数据的改变不会影响到另一个进程，保证了进程的独立性，而对于上面我们所说的父进程和子进程而言，子进程的地址空间从父进程拷贝，页表都指向同一块物理内存，但是即使此时的数据是共享的，在修改数据的时候也会发生我们所说的写时拷贝，保证了进程的独立性
:::

3.编译器也以统一的视角来进行编译代码

4.进程的控制

1.创建

1.1创建fork()

#include <unistd.h>	//所需头文件
pid_t fork(void);	//fork 函数

image

理解:

**1.**fork()函数再操作系统内部,子进程被创建的时候,进程都在ready队列中,准备被调度,fork()之后父子进程代码被共享,return会被调度两次.

**2.**父进程返回子进程的PID，给子进程返回0

**3.**pid_t 相当于typedef int

**4.**当进程过多或者用户进程数超过限制的时候,fork()会失败

1.2写时拷贝机制

image

image

2.终止

2.1查看最近一次进程运行的退出码

echo $?

进程退出后，os会释放对应的内核数据结构、代码和数据

main函数退出，表示整个程序退出

程序中的函数退出，函数运行结束

2.2退出方式

1.对于运行的进程:kill -9 PID和ctrl+c的方式
2.内部终止通过函数exit()和_exit()实现
void exit(int status);
void _exit(int status);

但是使用上其实是有区别的:

image

由此可见:exit()是要刷新缓冲区的

practice:

test31.cpp

image

现象

image

test32.cpp

image

现象

image

3.exit和return的区别

1.exit是函数；return是关键字

2.exit是系统调用级别的，它表示一个进程的结束；return是语言级别的，它表示调用堆栈的返回

3.exit是进程的退出；return是函数的退出

4.exit函数结束进程，删除进程使用的内存空间，并将进程的状态返回给操作系统（一般是用0表示正常终止，非0表示异常终止）；return是结束函数的执行，将函数的执行信息传其他调用函数使用

5…非主函数中调用exit和return区别很明显，但是在main函数中调用区分不大，多数情况效果一样

3.等待

理论

image

之前在11章时就讲过当父进程没有等待并接收其退出码和退出状态的时候，OS无法释放对应的内核数据结构+代码和数据，出现僵尸进程

  1. 为了避免这种情况，父进程可以通过函数等待子进程运行结束，此时父进程还处于阻塞状态

  2. 子进程必须对子进程进行负责

等待函数

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

pid_t wait(int* status);

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

  1. wait成功返回被等待进程pid，等待时返回0，失败返回-1

  2. 参数:不关心子进程退出可以设置为NULL

waitpid:

关于三个参数:

1.**pid** 表示所等子进程的 **PID**

2.**status** 该参数是一个输出型参数，由操作系统填充 ,如果传递NULL，表示不关心子进程的退出状态信息。否则**，操作系统会根据该参数，将子进程的退出信息反馈给父进程**。status不能简单的当作整形来看待，可以当作位图来看待

image

3.**options** 为选项，比如可以选择父进程是否需要阻塞等待子进程退出,默认为0

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

int main()
{
  //演示 waitpid()
  pid_t id = fork();  //创建子进程
  if(id == 0)
  {
    int time = 5;
    int n = 0;
    while(n < time)
      {
        printf("我是子进程，我已经运行了:%d秒 PID:%d   PPID:%d\n", n + 1, getpid(), getppid());
        sleep(1);
        n++;
      }

    exit(244);  //子进程退出
  }

  int status = 0; //状态
  pid_t ret = waitpid(id, &status, 0); //参数3 为0，为默认选项

  if(ret == -1)
  {
    printf("进程等待失败！进程不存在！\n");
  }
  else if(ret == 0)
  {
    printf("子进程还在运行中！\n");
  }
  else
  {
    printf("进程等待成功，子进程已被回收\n");
  }

  printf("我是父进程, PID:%d   PPID:%d\n", getpid(), getppid());

  //通过 status 判断子进程运行情况
  if((status & 0x7F))
  {
    printf("子进程异常退出，core dump：%d   退出信号：%d\n", (status >> 7) & 1, (status & 0x7F));
  }
  else
  {
    printf("子进程正常退出，退出码：%d\n", (status >> 8) & 0xFF);
  }

  return 0;
}

代码解释:

  if((status & 0x7F))
  {
    printf("子进程异常退出，core dump：%d   退出信号：%d\n", (status >> 7) & 1, (status & 0x7F));
  }
  else
  {
    printf("子进程正常退出，退出码：%d\n", (status >> 8) & 0xFF);
  }
  1. 异常退出检查：status & 0x7F：这里使用按位与操作检查 status 的低 7 位。如果结果不为零，表示子进程是由于接收到信号而退出的，而不是正常退出的。

image

可以使用(**WIFEXITED(status)** **判断进程退出情况，当宏为真时，表示进程正常退出)**代替

  1. (status >> 8) & 0xFF：这一部分提取了 status 的高 8 位，表示子进程的退出码

image

可以使用（**WEXITSTATUS(status)** 相当于 **(status >> 8) & 0xFF****，直接获取退出码）**代替

现象:

image

等待时执行

options参数改为WNOHANG，也就是父进程处于非阻塞状态，父进程进入等待轮询状态，不断获取子进程是否退出，如果没有退出，就可以做别的事情。

waitpid(id, &status, WNOHANG);
pracitice:
#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h> //进程等待相关函数头文件
#include<stdlib.h>
int main()
{
  //演示 waitpid()
  pid_t id = fork();  //创建子进程
  if(id == 0)
  {
    int time = 9;
    int n = 0;
    while(n < time)
    {
      printf("我是子进程，我已经运行了:%d秒 PID:%d   PPID:%d\n", n + 1, getpid(), getppid());
      sleep(1);
      n++;
    }

    exit(244);  //子进程退出
  }

  int status = 0; //状态
  pid_t ret = 0;
  while(1)
  {

    ret = waitpid(id, &status, WNOHANG); //参数3 设置为非阻塞状态
    
    if(ret == -1)
    {
      printf("进程等待失败！进程不存在！\n");
      break;
    }
    else if(ret == 0)
    { 
      printf("子进程还在运行中！\n");
      printf("我可以干一些其他任务\n");
      sleep(3);
    }
    else
    {
      printf("进程等待成功，子进程已被回收\n");
      //通过 status 判断子进程运行情况
      if(WIFEXITED(status))
      {
        printf("子进程正常退出，退出码：%d\n", WEXITSTATUS(status));
        break;
      }
      else
      {
        printf("子进程异常退出，code dump：%d   退出信号：%d\n", (status >> 7) & 1, (status & 0x7F));
        break;
      }
    }
  }

  return 0;
}

现象:

image

image

4.进程替换

4.1  为什么要进行进程替换？

image

4.2 七大替换函数

1.excel  使用list方式
#include <unistd.h>

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

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

int main()
{
  //execl 函数
  printf("程序替换前，you can see me\n");
  int ret = execl("/usr/bin/ls", "ls", "-a", "-l", NULL);

  //程序替换多发生于子进程，也可以通过子进程的退出码来判断是否替换成功
  if(ret == -1)
    printf("程序替换失败！\n");

  printf("程序替换后，you can see me again?\n");
  return 0;
}

链式传递方式:

image

现象:

image

2.execv  使用vector方式
#include <stdio.h>
#include <stdlib.h> //exit 函数头文件
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>

int main()
{
  //execv 函数
  pid_t id = fork();
  if(id == 0)
  {
    printf("子进程创建成功 PID:%d   PPID:%d\n", getpid(), getppid());
    char* const argv[] = 
    {
      "ls",
      "-a",
      "-l",
      NULL
    };	//argv 表，实际为指针数组

    execv("/usr/bin/ls", argv);

    printf("程序替换失败\n");
    exit(255); //如果子进程有此退出码，说明替换失败
  }

  int status = 0;
  waitpid(id, &status, 0); //父进程阻塞等待
  if(WEXITSTATUS(status) != 255)
  {
    printf("子进程替换成功，程序正常运行 exit_code:%d\n", WEXITSTATUS(status));
  }
  else
  {
    printf("子进程替换失败，异常终止 exit_code:%d\n", WEXITSTATUS(status));
  }

  return 0;
}

现象:

image

解释:WEXITSTATUS(status) != 255表示退出码如果不等于255就代表程序替换成功

3.execlp 可以自动到PATH变量中搜索
#include <stdio.h>
#include <stdlib.h> //exit 函数头文件
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>

int main()
{
  //execlp 函数
  pid_t id = fork();
  if(id == 0)
  {
    printf("you can see me\n");

    execlp("ls", "ls", "-a", "-l", NULL); //程序替换

    printf("you can see me again?");
    exit(-1);
  }

  int status = 0;
  waitpid(id, &status, 0);  //等待阻塞
  if(WEXITSTATUS(status) != 255)
    printf("子进程替换成功 exit_code:%d\n", WEXITSTATUS(status));
  else
    printf("子进程替换失败 exit_code:%d\n", WEXITSTATUS(status));

  return 0;
}

现象:

image

4.execvp  可以自动到PATH变量中搜索
#include <stdio.h>
#include <stdlib.h> //exit 函数头文件
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>

int main()
{
  //execvp 函数
  pid_t id = fork();
  if(id == 0)
  {
    printf("子进程创建成功 PID:%d   PPID:%d\n", getpid(), getppid());
    char* const argv[] = 
    {
      "ls",
      "-a",
      "-l",
      NULL
    };

    execvp("ls", argv);

    printf("程序替换失败\n");
    exit(-1); //如果子进程有此退出码，说明替换失败
  }

  int status = 0;
  waitpid(id, &status, 0); //父进程阻塞等待
  if(WEXITSTATUS(status) != 255)
  {
    printf("子进程替换成功，程序正常运行 exit_code:%d\n", WEXITSTATUS(status));
  }
  else
  {
    printf("子进程替换失败，异常终止 exit_code:%d\n", WEXITSTATUS(status));
  }

  return 0;
}
5.execle 将自定义或当前程序中的环境变量表传给代替换程序

程序1:execle1.cpp

#include<stdio.h>
#include<stdlib.h>
#include<iostream>
using namespace std;
extern char** environ;	//声明环境变量表nmain(int argc,char *argv[])
int main(int argc,char* argv[])
{
  int pos=0;
  while(environ[pos])
  {
    cout << environ[pos++] << endl;
  }
  for(int i=0;argv[i];i++)
  {
    printf("argv[%d]:%s\n",i,argv[i]);
  }
  printf("PATH:%s\n",getenv("PATH"));
  printf("PWD:%s\n",getenv("PWD"));
  printf("传递测试程序\n");
  return 0;
}

程序2:execle2.c

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<unistd.h>
#include<sys/types.h>
#include<sys/wait.h>
#include<assert.h>
extern char** environ;
int main()
{
  printf("process is running...\n");
  pid_t id =fork();
  assert(id!=-1);
  if(id==0)
  {
    sleep(1);
    putenv("myval=100");
    
    execle("./execle1","execle1","-a","-b",NULL,environ);
  }
  pid_t rid = waitpid(id,NULL,0);
  if(rid>0)
  {
    printf("wait sucess\n");
  }

  return 0;
}

实验现象:

image

image

红框:printf

黄框:存储程序的命令行参数

灰框:环境变量

6.execvpe和execvp但是最后一个参数可以传递环境变量表
#include <unistd.h>

int execvpe(const char* file, char* const argv[], char* const envp[]);
7.execve 真正的程序替换函数
#include <unistd.h>

int execve(const char* filename, char* const argv[], char* const envp[]);

参数1:待替换程序的路径

参数2:待替换程序名及其参数组成的 **argv** 表

参数3:传递给待替换程序的环境变量表

practice:
#include<stdio.h>
#include<unistd.h>
#include<stdlib.h>
#include<sys/wait.h>
#include<sys/types.h>
int main(int argc,char* argv[],char* envp[])
{
  pid_t id =fork();
  if(id==0)
  {
    printf("You can see me\n");
    execve("/usr/bin/ls",argv,envp);
    printf("You can see me again?");
    exit(-1);
  }
  int status=0;
  waitpid(id,&status,0);
  if(WEXITSTATUS(status)!=255)
        printf("子进程替换成功 exit_code:%d\n", WEXITSTATUS(status));
  else
    printf("子进程替换失败 exit_code:%d\n", WEXITSTATUS(status));

  return 0;
}

image

4.3 程序替换以后是否还为同一个进程

实验:

  1. practice

    #include
    #include <unistd.h>

    using namespace std;

    int main()
    {
    int n=4;
    while(n)
    {
    cout << “程序替换成功”;
    cout << " PID:" << getpid() << " PPID:" << getppid() << endl;
    sleep(1);
    n–;
    }

    return 0;
    }

2.practice1

#include<stdio.h>
#include<unistd.h>
#include<stdlib.h>
#include<sys/wait.h>
int main(int argc,char* argv[],char* envp[])
{
  pid_t id=fork();
  if(id==0)
  {
    printf("111");
    printf("process sucess PID:%d,PPID:%d",getpid(),getppid());
    fflush(stdout);
    execve("./practice",argv,envp);
    exit(-1);
  }
  int status=0;
  waitpid(id,&status,0);
  if(WEXITSTATUS(status)!=255)
        printf("子进程替换成功 exit_code:%d\n", WEXITSTATUS(status));
  else
    printf("子进程替换失败 exit_code:%d\n", WEXITSTATUS(status));

  return 0;
}

image

说明:

1.程序替换不是进程替换

2.因为是同一个进程，所以对父进程没有任何影响，体现了进程间的独立性。

我会说:明天更快乐
关注
  • 6
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
【操作系统】第五话·进程的切换与进程控制
kikokingの比特宇宙
04-02 8607
从今天开始，我们将要开启一个新的系列【闪耀计划】，没错！这是今年上半年的一整个系列计划！本专题目的是通过百天刷题计划，通过题目和知识点串联的方式，完成对计算机操作系统的复习和巩固；同时还配有专门的笔记总结和文档教程哦！想要搞定，搞透计算机操作系统的同学，本专栏将会通过模块化的分类，刷够1000道题，为大家提供点对点的考点相关知识轰炸！值得注意的是，本专栏将会通过教程+课后习题的方式来进行巩固教学，课后习题的题量也是算入总题数的哦！
操作系统（OS）进程与调度
Cristiano_san的博客
10-19 6021
一、进程的定义、组成、组织方式、特征 1.1 进程的定义 1、程序：一个指令序列 2、PCB：进程控制块，用来描述进程的各种信息 3、进程实体：由PCB、程序段、数据段三部分组成，又称为进程映像 4、进程：进程是进程实体的运行过程，是系统进行资源分配和调度的一个独立单位 5、PCB与进程的关系：PCB是进程存在的唯一标志。创建进程即创建进程实体中的PCB；撤销进程即撤销进程实体中的PCB 1.2 进程的组成 1、PCB：包括进程描述信息、进程控制和管理信息、资源分配清单、处理机相关信息 2、程序段：存放要执
2024考研408-操作系统 第二章-进程与线程 学习笔记
每个人都是独一无二的，把握好自己的节奏，跟着自己的心走。
07-12 1万+
目前正在备考24考研，现将24计算机王道的408学习整理的知识点进行汇总整理。博客目录索引(持续更新)进程控制本质：实现进程的状态转换。创建新进程就是创建态的过程，撤销已有进程则是终止态。进程通信（Inter-Process Communication, IPC）：是指的两个进程之间产生数据。实际例子：微博中的图文分享到其他应用当中。什么是线程，为什么要引入线程？引入了进程之后，想要实现进程的并发，那么我们对于时间片都是直接分配给某个进程，此时就能够实现边聊QQ和边听音乐。
操作系统实验：Linux下的进程控制实验
qq_45929428的博客
11-04 1万+
进程控制实验一、实验目的：二、实验平台：三、实验内容：1.进程的创建与销毁进程控制相关函数实验结果分析2.多进程并发执行time命令实验结果分析四、总结分析 一、实验目的： 加深对进程概念的理解，明确进程和程序的区别；掌握Linux操作系统的进程创建和终止操作，体会父进程和子进程的关系及进程状态的变化；进一步认识并发执行的实质，编写并发程序。 二、实验平台： 虚拟机：VMWare15.5.1 操作系统：CentOS7 64位 编辑器：Vim 编译器：Gcc 三、实验内容： 1.进程的创建与销毁 编写一段程序
操作系统 之 进程 学习总结
chenyfan_blog
06-18 3060
Linux 操作系统 之 进程 学习总结
操作系统实验——进程控制
xuanyuanchun的博客
10-30 5280
操作系统实验——进程控制 预习内容： 1.进程的概念 ⑴程序的并发执行 ⑵进程的定义 2.进程的描述 ⑴进程控制块 ⑵进程上下文 ⑶进程上下文切换 ⑷进程空间与大小 3. 进程状态及其转换 ⑴进程状态 ⑵进程状态转换 4.进程控制 ⑴进程创建与撤销 ⑵进程的阻塞与唤醒 实验目的与要求（及主要实验仪器、设备）： 1、理解进程的概念，明确进程和程序的区别。 2、理解并发执行的实质。 3、 掌握进程的创建、睡眠、撤销等进程控制方法 要求： （1）一台Windows7以上版本操作系统的计算机。 （2）计算机装有Mi
OS--学习笔记：操作系统概述
weixin_45609535的博客
09-01 2320
操作系统的概念、特征、功能、提供的服务概念：控制和管理整个计算机系统的硬件和软件资源，合理地组织、调度计算机的工作与资源的分配，进而为用户和其他软件提供方便接口与环境的程序集合。OS是计算机系统中最基本的系统软件。特征：并发(OS两个最基本的特性之一)、共享(OS两个最基本的特性之一)、虚拟、异步(进程以不可预知的速度向前推进)注意：OS利用时分复用和空分复用实现虚拟虚拟处理机技术：将一台物理机上的处理及虚拟为多台逻辑上处理机。...
计算机操作系统 第二章 进程的描述与控制
mobeiCanyue
04-09 2627
第二章进程的描述与控制复习 思维导图 2、进程的描述与控制 2.1、前驱图和程序执行 前驱图 有向无环图，用于描述进程之间执行的先后顺序 程序顺序执行 一个程序由若干个程序段组成，需按照某种先后顺序执行， 仅当前一段程序运行完成后，才会运行后一段程序 特征： 1、顺序性 2、封闭性 3、可再现性 程序并发执行 条件：不存在前驱关系的程序才有可能并发执行 特征： 1、间断性 2、失去封闭性 3、不可再现性...
操作系统期末总复习（题库）
热门推荐
忘之苡巛
12-11 12万+
问答题 什么是操作系统，主要功能有哪些？ 操作系统:计算机最基本最重要的基础性系统软件,可以使计算机系统能协调、高效和可靠地进行工作 主要功能:处理器管理、存储器管理、设备管理、文件管理、作业管理等功能模块 什么是微内核技术，主要有哪些功能？ 微内核技术把操作系统中更多的成分和功能放到更高的层次（即用户模式）中去运行，而留下一个尽量小的内核，用它来完成操作系统最基本的核心功能，称这种技术为微内核技术。 主要功能: 进程（线程）管理、低级存储器管理、中断和陷入处理等功能。 简述进程的基本状态及状态之间的转换
山东大学操作系统实验 —— 1.进程控制实验
SongyangJi
04-09 4538
示例实验 下面的实验想要完成的效果是，在执行这个程序的时候，通过命令行传参，执行shell命令。 // // Created by 吉松阳 on 2021/4/8. // #include "pctrl.h" int main(int argc, char *argv[]) { printf("参数有%d个\n", argc); int pid; //存放子进程号 int status; ////存放子进程返回状态 char *args[] = {"/usr/bin/ls"
os.rar_os 进程调度_操作系统进程调度_进程调度_进程调度算法
09-19
本文将深入探讨“os.rar”文件中涉及的“os 进程调度”、“操作系统进程调度”、“进程调度”以及“进程调度算法”的相关知识。 首先，进程是操作系统中一个重要的抽象概念，代表了正在执行的程序的一个实例。每个...
OS.rar_进程 调度_进程调度_进程调度 界面
09-23
进程是操作系统中执行的程序实例，每个进程都有自己的内存空间和状态。在多任务操作系统中，多个进程可以并发运行，但CPU的执行时间是有限的，因此需要一种机制来决定哪个进程应该获得CPU的时间片。这就是进程调度的...
os.rar_操作系统 进程调度
09-24
总结来说，操作系统进程调度是控制进程执行的关键机制，涉及多种策略，如FCFS、RR和MLFQ。通过编程实现这些调度算法，可以加深对操作系统内核工作原理的理解，并有助于提高解决实际问题的能力。在Java或C++环境中，...
os.rar_os 仿真_os 进程_仿真进程管理_进程调度_进程调度仿真
09-19
在"os.rar_os 仿真_os 进程_仿真进程管理_进程调度_进程调度仿真"这个压缩包中，我们可以期待找到关于操作系统仿真、进程管理和调度的相关知识，包括源代码和相关说明。 首先，我们要理解操作系统仿真。这是通过...
os.rar_CreateImage_Kernel_loader_mips 操作系统_os
09-23
总的来说，"os.rar_CreateImage_Kernel_loader_mips 操作系统_os"的讨论涵盖了操作系统开发的关键环节，包括kernel的构建、镜像文件的创建和加载机制。这些知识对于理解操作系统如何启动和运行，以及如何在特定硬件...
昇思25天学习打卡营第14天|LLM-文本解码原理--以MindNLP为例
最新发布
wwt72的博客
07-17 451
限制输出序列的最大长度为50个token。top-p=0.95，top-p采样表示在每一步生成token时，只从概率分布中累计概率达到95%的token中进行采样，有助于保持生成文本的流畅性和质量，同时允许一些低概率的token被选中，从而增加多样性。表示禁用了top-k采样，因为在top-k采样中，通常是从概率最高的k个token中随机选择一个token作为下一个输出，而这里设置为0表示不限制token的选择，实际上这将等同于使用 softmax 概率分布直接进行采样。这有助于提高生成文本的多样性。
探索Perl语言：入门学习与实战指南
洛秋的博客
07-15 753
Perl（Practical Extraction and Report Language）由Larry Wall于1987年创建，旨在帮助系统管理员简化日常任务。高效灵活：Perl的语法灵活多样，支持多种编程风格（过程式、面向对象等）。强大的文本处理能力：内置强大的正则表达式支持，是处理文本数据的利器。丰富的模块库：通过CPAN（Comprehensive Perl Archive Network）可以方便地获取和使用各类模块。Perl广泛应用于系统管理、Web开发、网络编程、数据库操作等领域。
NumPy库学习之np.random.rand函数
qq_46396470的博客
07-15 199
是 NumPy 库中的一个函数，用于生成随机数。这些随机数是从均匀分布 [0, 1) 中抽取的，即每个数都在0到1之间，但不包括1。
卷积神经网络学习问题总结
weixin_61681867的博客
07-17 248
均方误差函数（MSE）适用于回归任务，如预测房价、预测股票价格等。
计算机操作系统概念梳理.pdf
06-20
在第二章“进程的描述与控制”中，主要讨论了进程的生命周期、前驱图以及程序执行的概念，这些是操作系统中进程管理的基础，包括进程的创建、转换和终止，以及如何通过进程同步和互斥来协调并发执行的进程。...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值