ADD file via upload

2 months ago · ab06125f7e
parent 70b9decbca
commit ab06125f7e
1 changed files with 808 additions and 0 deletions
--- a/text2.txt
+++ b/text2.txt
@ -0,0 +1,808 @@
 第1关：进程的创建
 100
 学习内容
 记录
 评论
 任务描述
 相关知识
 进程的创建
 管理进程标识符
 编程要求
 测试说明
 进程管理：进程管理又称进程控制，主要完成进程各状态之间的转换，由具有特定功能的原语完成。进程管理包括进程创建，进程阻塞，进程终止和进程挂起等。
 任务描述
 编写一C语言程序，实现在程序运行时通过系统调用fork( )创建两个子进程，使父亲、女儿、儿子三进程并发执行： （1）在父进程中输出当前进程为父进程的提示“I am father”、当前进程的PID 和两个子进程的PID。 （2）在儿子进程中输出当前进程为儿子进程的提示“I am son”、当前进程的PID 和父进程的PID。 （3）在女儿进程中输出当前进程为女儿进程的提示“I am daughter”、当前进程的PID 和父进程的PID。
 相关知识
 为了完成本关任务，你需要掌握：1.如何创建进程，2.如何管理以及获取进程及其父进程标识符。
 进程的创建
 1.
 引起进程创建的事件：
 2.
 用户登录 作业调度 提供服务 应用请求
 3.
 4.
 进程创建过程： 申请空白PCB； 分配所需资源； 初始化PCB； 插入就绪队列。
 5.
 创建进程的进程称为父进程，被创建的进程称为子进程。
 1.进程创建新进程后有两种执行可能：
 父进程与子进程并发执行
 父进程等待，直到其某个或全部进程执行完毕
 新进程的地址空间也有两种可能：
 子进程是父进程的复制品（子进程具有和父进程相同的程序和数据）
 子进程加载另一个程序
 1.进程创建的控制函数
 fork ()函数通过系统调用创建一个与原来进程几乎完全相同的进程，两个进程可以做完全相同的事，根据初始参数或者传入的变量不同，两个进程也可以做不同的事。 一个进程调用fork ()函数后，系统先给新的进程分配资源，例如存储数据和代码的空间。然后把原来的进程的所有值都复制到新的进程中，只有少数值与原来的进程的值不同。相当于克隆了一个自己。
 fork()通过复制调用进程来建立新的进程，是最基本的进程建立过程
 为子进程分配一个空闲的进程控制块
 分配给子进程唯一标识pid
 以一次一页的方式复制父进程地址空间
 从父进程处继承共享资源，如打开的文件和当前工作目录等
 将子进程的状态设置为就绪，插入到就绪队列
 对子进程返回标识符0
 向父进程返回子进程的pid
 函数原型： 头文件： #include<unistd.h> #include<sys/types.h>
 pid_t fork( void); （pid_t 是一个宏定义，其实质是int，被定义在#include<sys/types.h>中） 返回值：若成功调用一次则返回两个值，子进程返回0，父进程返回子进程PID；否则，出错返回-1
 fork使用示例1--创建子进程，并在父子进程中打印各自身份信息 
 对上述代码进行编译、运行，结果如下：
 管理进程标识符
 Linux操作系统使用进程标识符来管理当前系统中的进程，进程的组标识符从父进程继承得到，用于区分进程是否同组。进程的标识符由系统分配，不能被修；组标识符可以通过相关系统调用进程修改。
 int getpid(); //取得当前进程的标识符（进程ID）。
 int getppid(); //取得当前进程的父进程ID。
 int getpgrp(); //取得当前进程的进程组标识符。
 int getpgid(int pid); //将当前进程的进程组标识符改为当前进程的进程ID，使其成为进程组首进程，并返回这一新的进程组标识符。
 fork使用示例2--创建子进程，并在父子进程中打印各自身份信息和进程标识符
 运行结果如下： 
 编程要求
 根据上面fork的应用示例，在右侧编辑器补充代码，完成实验任务的功能要求，并点击测试按钮即可。
 测试说明
 开始你的任务吧，祝你成功！
 #include<stdlib.h> 
 #include<unistd.h>
 #include<stdio.h>
 //-------begin---------
 int main()
 {
     int pid_son = fork();
     if(pid_son == 0){
         printf("I am son,%d,%d\n",getpid(),getppid());
         exit(0);
     }else if(pid_son > 0){
         int pid_daughter = fork();
         if(pid_daughter == 0)
         {
             printf("I am daughter,%d,%d\n",getpid(),getppid());
             exit(0);
         }else if(pid_daughter > 0)
         {
             printf("I am father,%d,%d,%d\n",getpid(),pid_son,pid_daughter);
             wait(NULL);
             wait(NULL);
         }
     }
     return 0;
 }
 第2关：加载新的进程映像
 100
 学习内容
 记录
 评论
 任务描述
 相关知识
 加载新的进程映像
 编程要求
 任务描述
 修改第一关的代码，在儿子进程中调用exec 函数族以执行系统命令ls，在女儿进程中调用exec函数族以执行系统命令pwd。
 相关知识
 为了完成本关任务，你需要掌握：如何加载新的进程映像。
 加载新的进程映像
 使用fork创建新进程后往往希望它能执行新的程序，在Linux中，进程创建和加载新进程映像是分离操作的。 在Linux中，当创建一个进程后，通常使用exec系列函数将子进程替换成新的进程映像。 exec()用新程序来重写当前进程。
 1.exec()示例代码
 2.int main()
 3.{…
 4.    int pid = fork();            // 创建子进程
 5.    if (pid == 0) {            // 子进程在这里继续
 6.        exec_status = execlp(“calc”, argc, argv0, argv1, …);
 7.        printf(“Why would I execute?”);
 8.    }  else {                // 父进程在这里继续
 9.    printf(“Whose your daddy?”);
 10.    …
 11.}
 exec()包括一系列系统调用，它们都是通过用一段新的程序代码覆盖原来的地址空间，实现进程执行代码的转换。
 
 允许进程“加载”一个完全不同的程序，并从main开始执行(即_start)。
 
 
 允许进程加载时指定启动参数(argc, argv)。
 
 exec调用成功时，它是相同的进程，PID没有改变，但是运行了不同的程序，代码段、堆栈和堆(heap)等完全重写。 Linux中并不存在exec()函数，exec函数族指的是一组函数，一共6个，分别是：
 #include <unistd.h> 1. int execl(const char *path, const char *arg, ...); execl 函数通过指定完整的文件路径 path 来执行新程序，后续参数以可变参数的形式传递给新程序，参数列表必须以 NULL 结尾。 例如：
 1.#include <stdio.h>
 2.#include <unistd.h>
 3.
 4.int main() {
 5.   // 执行 ls 命令，列出当前目录下文件信息
 6.   execl("/bin/ls", "ls", "-l", NULL);
 7.   perror("execl");  // 如果执行失败，输出错误信息
 8.   return 1;
 9.}
 2. int execlp(const char *file, const char *arg, ...); execlp 函数与 execl 类似，但它不需要指定完整的文件路径，会在环境变量 PATH 指定的目录中搜索 file 对应的可执行文件。参数同样以可变参数形式传递，以 NULL 结尾。 例：
 1.#include <stdio.h>
 2.#include <unistd.h>
 3.
 4.int main() {
 5.    // 执行 ls 命令，由于 PATH 包含 /bin 等目录，可直接用文件名
 6.    execlp("ls", "ls", "-l", NULL);
 7.    perror("execlp");  // 如果执行失败，输出错误信息
 8.    return 1;
 9.}
 3. int execle(const char *path, const char *arg, ..., char *const envp[]); execle 函数通过指定完整的文件路径 path 执行新程序，参数以可变参数形式传递，以 NULL 结尾。最后一个参数 envp 是一个指向环境变量数组的指针，用于为新程序设置环境变量。 例：
 1.#include <stdio.h>
 2.#include <unistd.h>
 3.
 4.int main() {
 5.    char *envp[] = {"MY_VAR=value", NULL};  // 自定义环境变量
 6.    // 执行 echo 命令，输出环境变量 MY_VAR 的值
 7.    execle("/bin/echo", "echo", "$MY_VAR", NULL, envp);
 8.    perror("execle");  // 如果执行失败，输出错误信息
 9.    return 1;
 10.}
 4. int execv(const char *path, char *const argv[]); execv 函数通过指定完整的文件路径 path 执行新程序，参数以字符串数组 argv 的形式传递，数组最后一个元素必须为 NULL。 例：
 1.#include <stdio.h>
 2.#include <unistd.h>
 3.
 4.int main() {
 5.    char *argv[] = {"ls", "-l", NULL};  // 命令参数数组
 6.    // 执行 ls 命令
 7.    execv("/bin/ls", argv);
 8.    perror("execv");  // 如果执行失败，输出错误信息
 9.    return 1;
 10.}
 5. int execvp(const char *file, char *const argv[]); execvp 函数与 execv 类似，但它不需要指定完整的文件路径，会在环境变量 PATH 指定的目录中搜索 file 对应的可执行文件。参数以字符串数组 argv 的形式传递，数组最后一个元素必须为 NULL。 例：
 1.#include <stdio.h>
 2.#include <unistd.h>
 3.
 4.int main() {
 5.    char *argv[] = {"ls", "-l", NULL};  // 命令参数数组
 6.    // 执行 ls 命令
 7.    execvp("ls", argv);
 8.    perror("execvp");  // 如果执行失败，输出错误信息
 9.    return 1;
 10.}
 6. int execve(const char *path, char *const argv[], char *const envp[]);
 execve 函数是 exec 函数族的底层实现，其他 exec 系列函数最终都会调用 execve。它通过指定完整的文件路径 path 执行新程序，参数以字符串数组 argv 的形式传递，数组最后一个元素必须为 NULL。最后一个参数 envp 是一个指向环境变量数组的指针，用于为新程序设置环境变量。 例：
 1.#include <stdio.h>
 2.#include <unistd.h>
 3.
 4.int main() {
 5.    char *argv[] = {"echo", "$MY_VAR", NULL};  // 命令参数数组
 6.    char *envp[] = {"MY_VAR=value", NULL};  // 自定义环境变量
 7.    // 执行 echo 命令，输出环境变量 MY_VAR 的值
 8.    execve("/bin/echo", argv, envp);
 9.    perror("execve");  // 如果执行失败，输出错误信息
 10.    return 1;
 11.}
 注意事项 这些函数如果执行成功，不会返回原程序；如果执行失败，会返回 -1，并设置 errno 以指示错误原因。 在使用可变参数时，记得以 NULL 结尾；在使用数组形式传递参数时，数组最后一个元素必须为 NULL。 除 execvp 和 execlp 外，其他函数都需要指定完整的文件路径。以上函数在使用时，任选其一即可。
 例如，父进程创建子进程，子进程在其代码中调用exec 函数族以执行系统命令date.其代码如下：
 编译运行后结果如下：
 编程要求
 请在右侧编辑器中补全代码，然后点击测试按钮即可。 注意：由于测评需求，请如上例所示在每个printf语句后面添加fflush(stdout)以强制刷新缓冲区。
 开始你的任务吧，祝你成功！
 #include <stdio.h>
 #include <unistd.h>
 #include <sys/types.h>
 #include <sys/wait.h>
 int main() {
     pid_t son_pid, daughter_pid;
   //begin
     son_pid = fork();
     if(son_pid == 0){
       printf("I am son,%d,%d\n",getpid(),getppid());
       fflush(stdout);
       execlp("ls", "ls", NULL);
       // exit(0);
     }else if(son_pid > 0){
       daughter_pid = fork();
       if(daughter_pid == 0)
       {
         printf("I am daughter,%d,%d\n",getpid(),getppid());
         fflush(stdout);
         execlp("pwd", "pwd", NULL);
         // exit(0);
       }else if(daughter_pid > 0)
       {
         printf("I am father,%d,%d,%d\n",getpid(),son_pid,daughter_pid);
         fflush(stdout);
         wait(NULL);
         wait(NULL);
       }
     }
   //end
     return 0;
 }
 第1关：进程的阻塞与退出
 100
 学习内容
 记录
 评论
 任务描述
 相关知识
 进程的阻塞及其原语的使用
 进程的撤销及其原语的使用
 编程要求
 任务描述
 在实验二（上）第一关代码的基础上，修改程序，在父进程中调用wait()，儿子和女儿进程中调用exit()系统调用“实现”进程同步推进。父进程中获取子进程的PID号及结束状态值,儿子进程退出运行时返回状态值4，女儿进程结束运行时返回状态值5。多次反复运行改进后的程序，观察并记录运行结果。
 相关知识
 进程管理：进程管理又称进程控制，主要完成进程各状态之间的转换，由具有特定功能的原语完成。 除了实验二（上）中介绍的进程创建原语fork（），还包括进程撤销原语exit()以及进程阻塞原语wait ()/waitpid()。
 为了完成本关任务，你需要掌握：1.进程的阻塞及其原语的使用，2.进程的退出及其原语的使用。
 进程的阻塞及其原语的使用
 处于运行状态的进程，在其运行过程中期待某一事件的发生，如等待键盘输入、等待磁盘数据传输完成、等待其它进程发送消息，当被等待的事件未发生时，由进程自己调用阻塞原语，使自己由运行态转变为阻塞态。其使用的原语或者系统调用函数为Wait()。 wait()系统调用用于父进程等待子进程的结束。
 子进程结束时通过exit()向父进程返回一个值
 父进程通过wait()接受并处理返回值
 wait()系统调用的功能
 
 有子进程存活时，父进程进入等待状态，等待子进程的返回结果
 
 当某子进程调用exit()时,唤醒父进程，将exit()返回值作为父进程中wait的返回值
 
 
 有僵尸子进程等待时，wait()立即返回其中一个值
 
 
 无子进程存活时，wait()立刻返回
 
 wait系统调用的原型
 头文件： #include<sys/types.h> #include<sys/wait.h> 函数原型： pid_t wait (int * status)； 返回值： 如果执行成功则返回子进程识别码或标志符（PID），如果有错误发生则返回-1。
 wait()会暂时停止目前进程的执行，直到有信号来到或子进程结束。如果在调用wait()时子进程已经结束，则wait()会立即返回子进程结束状态值。子进程的结束状态值会由参数status 返回，而子进程的进程识别码也会一起返回。如果不在意结束状态值，则参数status 可以设成NULL。
 wait()系统调用用于父进程等待子进程的结束，但并未指明是哪个子进程，当父进程有多个子进程时，可以使用waitpid()等待指定子进程结束。
 waitpid（）系统调用原型如下： 头文件： #include<sys/types.h> #include<sys/wait.h> 函数原型：pid_t waitpid(pid_t pid,int * status,int options)； 返回值：如果执行成功则返回子进程识别码（PID），如果有错误发生则返回-1。 pid参数说明：
 • pid > 0：表示等待进程ID为pid的子进程； • pid = 0：表示等待与调用进程同一进程组的任意子进程； • pid = -1：表示等待任意子进程； • pid < -1：表示等待所有子进程中，进程组ID与pid绝对值相等的所有子进程； 参数options是一个位掩码，可以同时存在多个标志。其值可以为0或下面的组合。
 WNOHANG 如果没有任何已经结束的子进程则马上返回，不予以等待。
 WUNTRACED 如果子进程进入暂停执行情况则马上返回，但结束状态不予以理会。
 以上两个原语中都有status参数，该参数用于存放子进程的结束状态，下面有几个宏可判别结束情况：
 WIFEXITED（status）如果子进程正常结束则为非0 值。
 WEXITSTATUS（status）取得子进程exit()返回的结束代码，一般会先用 WIFEXITED 来判断是否正常结束才能使用此宏。
 WIFSIGNALED（status）如果子进程是因为信号而结束则此宏值为真。
 WTERMSIG（status）取得子进程因信号而中止的信号代码，一般会先用 WIFSIGNALED 来判断后才使用此宏。
 WIFSTOPPED（status）如果子进程处于暂停执行情况则此宏值为真。一般只有使用WUNTRACED 时才会有此情况。
 WSTOPSIG（status）取得引发子进程暂停的信号代码，一般会先用WIFSTOPPED 来判断后才使用此宏。
 进程的撤销及其原语的使用
 进程的撤销意味着结束进程，收回进程所占用的资源，关闭打开的文件、断开网络连接、回收分配的内存以及撤销该进程的PCB。 进程结束执行时调用exit()，完成进程资源回收。 exit()系统调用的功能：
 
 将调用参数作为进程的“结果”
 
 
 关闭所有打开的文件等占用资源
 
 
 释放内存
 
 
 释放大部分进程相关的内核数据结构
 
 
 检查是否父进程是存活着的
 
 如存活，保留结果的值直到父进程需要它，进入僵尸（zombie/defunct）状态 如果没有，它释放所有的数据结构，进程结束
 
 
 清理所有等待的僵尸进程 进程终止是最终的垃圾收集(资源回收)
 
 例如 在下例中，子进程运行结束调用exit（），并把参数5作为结果返回给父进程，父进程调用wait()等待子进程的结束，若父进程调用wait时，子进程未结束，则父进程进入阻塞状态，直到子进程调用exit（）将其唤醒，并把结束的值5传递给它；若子进程先于父进程结束，则会保留结果值5直到父进程调用wait(),并让自己进入僵尸状态。
 1. #include<stdlib.h>
 2. #include <stdio.h>
 3. #include<unistd.h>
 4. #include<sys/types.h>
 5. #include<sys/wait.h>
 6. int main(int argc, char ** argv)
 7. {
 8.      pid_t pid;
 9.      int status,i;
 10.      if(fork()== 0)
 11.     {
 12.          printf("This is the child process .pid =%d\n",getpid());
 13.          exit(5);
 14.     }
 15.      else
 16.     {
 17.         sleep(1);
 18.         printf("This is the parent process ,wait for child...\n");
 19.         pid=wait(&status);
 20.         if(WIFEXITED（status）)
 21.         i=WEXITSTATUS(status);
 22.         printf("child’s pid =%d .exit status=%d\n",pid,i);
 23.      }
 24. }
 将上述代码通过gcc编译运行，其结果如下图所示： 
 编程要求
 根据提示，在右侧编辑器补充代码，并点击评测按钮评测即可。
 开始你的任务吧，祝你成功！
 代码文件
 实验环境1
 1
 2
 3
 4
 5
 6
 7
 8
 9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 #include<stdlib.h>
 #include<unistd.h>
 #include<sys/types.h>
 #include<sys/wait.h>
 #include<stdio.h>
 int main()
 {  
   int fpid,fpid2,cpid1,cpid2;
   int status,i,j;
   fpid=fork();
   if(fpid<0)
   {
   perror("fork failed\n");
   exit(0);
   }
   else if(fpid==0)
   {
     printf("I am son, my PID is 
 %d, parent PID is %d\n",getpid(),
 getppid());  
     printf("I am working\n");
     sleep(1);
 测试结果
 1/1全部通过
 
 
 #include<stdlib.h>
 #include<unistd.h>
 #include<sys/types.h>
 #include<sys/wait.h>
 #include<stdio.h>
 int main()
 {  
   int fpid,fpid2,cpid1,cpid2;
   int status,i,j;
   fpid=fork();
   if(fpid<0)
   {
   perror("fork failed\n");
   exit(0);
   }
   else if(fpid==0)
   {
     printf("I am son, my PID is %d, parent PID is %d\n",getpid(),getppid());  
     printf("I am working\n");
     sleep(1);
     printf("I am done\n");
     exit(4);
   }
   else if (fpid>0) 
     {
     /* 创建第二个子进程（女儿） */
         fpid2=fork();
         if (fpid2==0) 
         {
         // 女儿进程执行代码
             printf("I am daughter, my PID is %d, parent PID is %d\n",getpid(),getppid());
             printf("I am working\n");
             sleep(1);
             printf("I am finished\n");
             exit(5);
         } 
         else if (fpid2<0) 
         {
             perror("Second fork failed");
             return 1;
         }
         else if(fpid2>0)
         {/* 父进程执行代码 */
             printf("I am father, my PID is %d, son PID is %d, daughter PID is %d\n",
             getpid(),fpid,fpid2);  
             fpid=wait(&status);
             i=WEXITSTATUS(status);  
             fpid2=wait(&status);                 
             j=WEXITSTATUS(status);
             printf("Child %d exited with status %d\n",fpid,i);
             printf("Child %d exited with status %d\n",fpid2,j);
         }
     }   
 }
 第1关：进程调度--时间片轮转调度算法
 300
 学习内容
 记录
 评论
 任务描述
 相关知识
 进程控制块PCB的定义
 就绪队列和运行队列的创建
 随机数的产生
 时间片轮转调度算法的原理及其流程
 编程要求
 任务描述
 本关任务：编写程序，模拟实现单处理机系统中的进程调度算法，实现对多个进程的模拟调度。具体为：定义合理的PCB数据结构，建立含有8个进程结点的就绪队列（PCB组织成单链表形式），每个进程的要求运行时间随机产生，但不小于1不大于15。设置时间片大小（3~6），使用时间片轮转调度算法，实现对8个进程的模拟调度。
 相关知识
 进程控制块通过链表队列的方式组织起来，系统中存在运行队列和就绪队列（为简单起见，不设阻塞队列），进程的调度就是进程控制块在运行队列和就绪队列之间的切换。当需要调度时，从就绪队列中挑选一个进程占用处理机，即从就绪队列中删除一个进程，插入到运行队列中，当占用处理机的进程运行的时间片完成后，放弃处理机，即在运行队列中的进程控制块经过一段时间（时间片）后，从该队列上删除，如果该进程运行完毕，则删除该进程（节点）；否则，则插入到就绪队列中。
 为了完成本关任务，你需要掌握：1.进程控制块PCB的定义 2.就绪队列和运行队列的创建 3.随机数的产生 4.时间片轮转调度算法的原理 
 进程控制块PCB的定义
 进程控制块可以根据具体的调度算法来确定自身所包含的信息，如进程名、优先数、到达时间、需要运行时间、已用CPU时间、进程状态等。进程控制块用C语言中的结构体来表示。本实验中定义进程控制块内容包括参数①进程名name；②要求运行时间 runtime；③已运行时间runedtime；④本轮运行时间killtime。
 struct PCB { int name; int runtime; int runedtime; int killtime; struct PCB *next; }; typedef struct PCB PCB;
 就绪队列和运行队列的创建
 就绪队列和运行队列的创建实际就是单链表的创建，单链表中的结点就是进程的PCB。就绪队列中的结点是没有运行完且处于就绪状态的进程PCB，运行队列中的结点是处于运行状态的进程PCB，初始为空。关于单链表的创建，这是数据结构的范畴，这里不再赘述。
 由于运行队列初始为空，这里只给出就绪队列的创建代码。
 1.#define LEN sizeof(PCB)
 2.PCB *runqueue;//运行队列指针
 3.PCB *top,*tail,*temp;//就绪队列指针
 4.int i;
 5.srand((int)time(0));
 6.for(i=0;i<NUM;i++)//NUM为就绪队列中进程的个数
 7.{
 8.  temp=(PCB*)malloc(LEN);//申请空白PCB
 9.  temp->name=i;//初始化进程名
 10.  temp->runtime=rand()%15;//初始化进程需要运行的时间
 11.  temp->runedtime=0;//初始化进程已经运行的时间
 12.  temp->next=NULL;//初始化该进程PCB所指向的下一个进程PCB;
 13.  temp->killtime=0;//初始化该进程本轮运行的时间；
 14.  if(i==0) //如果是创建的第一个进程PCB；
 15.  {
 16.    top=temp; //头尾指针均指向它；
 17.    tail=temp;
 18.  }
 19.  else//如果不是链表中的第一个节点，则将当前进程PCB插入到链表尾部；
 20.  {
 21.    tail->next=temp;
 22.    tail=temp;
 23.  }
 24.  printf("process name %d, runtime=%d, runedtime=%d,killtime=%d\n", tail->name,tail->runtime,tail->runedtime,tail->killtime); //队列创建好后，打印就绪队列信息；
 25.}
 随机数的产生
 本实验中要求每个进程的运行时间随机产生，库函数中系统提供了两个函数用于产生随机数：srand()和rand()。 函数一：int rand(void); 从srand (seed)中指定的seed开始，返回一个[0,RAND_MAX（0x7fff）]间的随机整数。
 函数二：void srand(unsigned seed)； 参数seed是rand()的种子，用来初始化rand()的起始值。函数rand()是真正的随机 数生成器，而srand()会设置供rand()使用的随机数种子。 如果你在第一次调用rand()之前没有调用srand()，那么系统会为你自动调用srand()。而使用同种子相同的数调用 srand() 会导致相同的随机数序列被生成。通常用srand( (unsigned) time(0) )或者srand((unsigned)time(NULL))来产生种子. 关于time_t time(0)：time_t被定义为长整型，它返回从1970年1月1日零时零分零秒到目前为止所经过的时间，单位为秒。
 例如：
 1.#include<time.h>
 2.#include<stdio.h>
 3.void main()
 4.{
 5.   int i,j;   
 6.   srand(10);    //srand((int)time(0));
 7.   for (i=0; i<10; i++) 
 8.   {    
 9.     j = (int) (rand())%20;
 10.     printf(" %d\n ", j);
 11.   }
 12.}
 时间片轮转调度算法的原理及其流程
 第1步：取就绪队列的队首结点（作为被调度的进程），将其从就绪队列中删除，修改就绪队列队首指针后移（涉及到单链表中节点的删除），并将其插入到运行队列中模拟调度运行（涉及到单链表中节点的插入） 第2步：调度运行队列结点，即修改运行队列中进程PCB的要求运行时间，将原本要求运行时间减去本轮时间片时间； 第3步：a．若修改后要求运行时间<=0，则表示该进程结点运行完毕，修改进程结点的PCB信息，记录runtime，runedtime，killtime等信息。并将结点信息输出。b．否则，表示该进程结点未完成，记录runtime，runedtime，killtime等信息，将结点信息输出。并将该运行进程的PCB所对应的节点置于就绪队列的队尾，等待下次调度，同时修改就绪队列中的队尾指针。 第4步：若就绪队列非空，则继续执行第1步，直至就绪队列为空。
 编程要求
 在右侧编辑器补充代码，完成使用时间片轮转调度算法实现对8个进程就绪队列的模拟调度。
 开始你的任务吧，祝你成功！
 #include <stdio.h>
 #include <stdlib.h>
 #include <malloc.h>
 #include <time.h>
 #define NUM 8
 #define LEN sizeof(PCB)
 struct PCB
 {
   int name;
   int runtime;
     int runedtime;
   int killtime;
    struct PCB *next;
 };
 typedef struct PCB PCB;
 void main()
 {
    int timeslice=5;
    PCB *runqueue;
    PCB *top,*tail,*temp;
    int i;
    srand((int)time(0));
    for(i=0;i<NUM;i++)
    { 
      temp=(PCB*)malloc(LEN);
      temp->name=i;
      temp->runtime=rand()%15+1;
      temp->runedtime=0;
      temp->killtime=0;
      temp->next=NULL;
      if(i==0) 
      {
        top=temp; 
        tail=temp;
      }
      else
      {
        tail->next=temp;
        tail=temp;
      }
      printf("START:process name %d, runtime=%d, runedtime=%d,killtime=%d\n",tail->name,tail->runtime,tail->runedtime,tail->killtime); 
    }
    printf("******************************\n");
    while(top!=NULL)
    { 
       runqueue=top;
       top=top->next;
       runqueue->next=NULL;
       runqueue->runtime=runqueue->runtime-timeslice;
       if(runqueue->runtime<=0)
       {
         runqueue->killtime=runqueue->killtime+timeslice;
         runqueue->runedtime=runqueue->runedtime+runqueue->killtime;
         runqueue->runtime=0;
         printf("process name %d, runtime=%d, runedtime=%d,killtime=%d...END...\n",runqueue->name,runqueue->runtime,runqueue->runedtime,runqueue->killtime);
       }
      else
       {
         runqueue->runedtime += timeslice;
         runqueue->runtime -= timeslice;
         printf("process name %d, runtime=%d, runedtime=%d,killtime=%d\n",runqueue->name,runqueue->runtime,runqueue->runedtime,runqueue->killtime);
         if (tail != NULL) 
         {
           tail->next = runqueue;
         } else {
           top = runqueue;
         }
         tail = runqueue;
      }
    }
 }
 第1关：存储管理
 200
 学习内容
 记录
 评论
 任务描述
 相关知识
 实验原理
 如何定义内存块
 分配内存流程
 回收内存流程
 编程要求
 测试说明
 任务描述
 本关任务：根据流程图和参考程序，完成模拟内存分配和回收过程。内存空间大小为100，进程数为5，每个进程所需空间为随机产生，大小为1~20，编制程序，首先对5个进程进行内存分配，然后回收指定的进程空间，并进行适当的空闲分区合并操作，要求每次操作结束后都能显示当前的内存分配情况。
 相关知识
 为了完成本关任务，你需要掌握：
 1.实验原理
 2.如何定义内存块；
 3.分配内存流程；
 4.回收内存流程。
 实验原理
 使用一个链表来模拟内存存储空间，建立内存块来记录内存分配使用情况，通过随机产生进程及其所需要的内存来模拟真实的进程。通过给进程分配内存及回收来实现动态分区分配存储管理方法。 初始化：链表中只有一个节点，代表整个内存空间，大小为100，起始地址为0，使用标志为0（表示空闲）。 分配阶段：对于进程（5个）及其随机产生的需求空间（每个进程需求空间1～20），从链表中第一个节点所指示的可用内存中进行分配，即进行节点的创建和插入以及相关参数的修改。 回收阶段：要求用户输入指定回收的进程空间，根据用户指定的进程名，进行单链表查找，定位到指定进程所代表的节点后，再判断本次要回收的进程内存空间其左右节点是否为空闲块，如若是，则需要进行空闲块合并，在程序里则需要进行节点删除和相关参数的修改。如果不是，则直接修改对应节点参数即可。
 图示说明： 假设内存空间初始阶段为100，进程数为5，每个进程随机产生的内存需求空间为15，14，17，18，12。则表示内存中各内存块的链表变化过程为： 分配阶段 初始状态： 
 进程1申请大小为15的内存空间，为其分配后： 
 进程2又申请大小为14的内存空间，为其分配后： 
 进程3又申请大小为17的内存空间，为其分配后： 
 进程4又申请大小为18的内存空间，为其分配后： 
 进程5又申请大小为12的内存空间，为其分配后： 
 回收阶段：
 假设回收进程内存空间的顺序3，2，4，1，5。则内存中链表的变化过程为： 
 如何定义内存块
 如上面图示所示，对于内存块数据结构的定义，其包括参数 ①进程名name； ②起始地址 address； ③长度 length； ④标志 flag，表示该块是否被分配。 于是，内存块被定义为结构体：
 struct MEMORY_BLOCK { int name; int address; int length; int flag; struct MEMORY_BLOCK *next; };
 分配内存流程
 系统利用某种分配算法（本实验中默认使用的是首次适应），从空闲分区链(表)中找到所需大小的分区。 设请求的分区大小为u.size，表中每个空闲分区的大小可表示为m.size。 若m.size-u.size<=size(事先规定的不可再切割的剩余分区的大小，碎片)，说明多余部分太小，可不再切割，将整个分区分配给请求者。 否则，从该分区中按请求大小划分出一块内存空间分配出去，余下的留在空闲分区链（表）中，将分配区首地址返回给调用者。
 回收内存流程
 回收内存：当进程运行完毕释放内存时，需要对该内存进行回收。 根据回收区的首址，从空闲区链(表)中找到相应的插入点，此时可能出现以下四种情况之一。
 1.回收区与插入点的前一个空闲分区相邻接
 直接修改链表中前一个空闲分区对应的结点，将其大小修改为F1+回收区之和,并删除回收区所对应的链表中的结点，如上图中回收阶段的回收4号进程。
 1.回收区与插入点的后一个空闲分区相邻接 
 直接修改链表中回收区所对应的空闲分区结点，将其大小修改为回收区+F2之和，名称改为-1，并同步删除F2分区所对应的链表中的结点，如上图中回收阶段的回收2号进程。
 1.回收区同时与插入点的前、后两个分区相邻接
 修改链表中F1分区所对应的空闲分区结点，将其大小修改为F1+回收区+F2之和，并同步删除回收区以及F2分区所对应的链表中的结点，如上图中回收阶段的回收5号进程。
 1.回收区不与任何空闲区邻接
 直接修改回收区所对应的结点中的标志位和名称，将其名称改为-1，标志位改为0即可。
 其流程图如下： 
 编程要求
 根据提示，在右侧编辑器补充代码，完成模拟内存分配和回收过程。内存空间大小为100，进程数为5，每个进程所需空间为随机产生，大小为1~20，编制程序，首先对5个进程进行内存分配，然后回收指定的进程空间，并进行适当的空闲分区合并操作，要求每次操作结束后都能显示当前的内存分配情况。
 测试说明
 平台会对你编写的代码进行测试：
 开始你的任务吧，祝你成功！
 #include <stdio.h>
 #include <stdlib.h>
 #include <malloc.h>
 #include <time.h>
 #define LEN sizeof(MEMORY_BLOCK)
 #define NUM 5
 struct MEMORY_BLOCK
 {
     int name;
     int address;
     int length;
     int flag;
     struct MEMORY_BLOCK *next;
 };
 typedef struct MEMORY_BLOCK MEMORY_BLOCK;
 void allocation(MEMORY_BLOCK *Header,int name,int length_p);
 void reclaim(int processname, MEMORY_BLOCK *Header);
 void main()
 {
     int length_p,i;
     int processname;
     MEMORY_BLOCK *Header,*t;
     Header=(MEMORY_BLOCK*)malloc(LEN);//初始化存储空间
     Header->name=-1;
     Header->address=0;
     Header->length=100;
     Header->flag=0;
     Header->next=NULL;
     srand(0);
     for(i=1;i<=NUM;i++)
     {
         length_p=rand()%20+1;   //随机产生进程所需存储空间，至少为1;
         allocation(Header,i,length_p);
     }
     printf("内存分配情况:  \n");
     t=Header;
     while(t!=NULL)
     {
         printf("process name %d, address=%d, length=%d,flag=%d\n",t->name,t->address,t->length,t->flag);
         t=t->next;
     }
     printf("请输入回收的进程号(输入0结束):\n");
     scanf("%d",&processname);   
     while(processname!=0)
     {
         printf("回收 process name %d\n",processname);
         reclaim(processname,Header);
         t=Header;
         while(t!=0)
         {
             printf("process name %d, address=%d, length=%d,flag=%d\n",t->name,t->address,t->length,t->flag);
             t=t->next;
         }
         if (Header->next==NULL) break;
         printf("请输入回收的进程号(输入0结束):\n");
         scanf("%d",&processname);
     }
     printf("当前内存分配情况：\n");
     t=Header;
     while(t!=0)
     {
         printf("process name %d, address=%d, length=%d,flag=%d\n",t->name,t->address,t->length,t->flag);
         t=t->next;
     }
 }
 void reclaim(int processname, MEMORY_BLOCK *Header)
 {
     MEMORY_BLOCK *temp,*t,*tt;
     t=Header;
     temp=t;
     while(t->name!=processname)
     {
         temp=t;
         t=t->next;
     } 
     if(t->next!=NULL)//t非尾结点
         if(temp->flag==0&&t->next->flag==0)//左右为空
         {
             temp->name=-1;
             temp->length=temp->length+t->length+t->next->length;
             tt=t->next;
             temp->next=tt->next;
         }
         else if(temp->flag==0) //左为空
         {
             temp->name=-1;
             temp->length=temp->length+t->length;
             temp->next=t->next;
         }
             else if(t->next->flag==0) //右为空
             {
                 t->name = -1;
                 t->flag = 0;
                 t->length=t->length + t->next->length;
                 tt = t->next;
                 t->next = tt->next;
             }
                 else // 左右不为空
                 {
                     t->name = -1;
                     t->flag = 0;
                 }
     else//t是尾结点
     {
         if(temp->flag==0) //左为空
         {
             temp->length = temp->length + t->length;
             temp->next = NULL;
         }
         else // 左不为空
         {
             t->name = -1;
             t->flag = 0;
         }
     }
 }
 void allocation(MEMORY_BLOCK *Header,int name,int length_p)
 {
     MEMORY_BLOCK *temp,*t,*tt;
     int minsize=2; //不可切割的分区阈值
     t=Header;
     while(t!=0)
     {
         if(t->length>length_p&&t->flag==0) break;
         t=t->next;
     }
     if(t->length-length_p>minsize) //分割
     {
         temp=(MEMORY_BLOCK*)malloc(LEN);//temp=new MEMORY_BLOCK;
         temp->name=-1;
         temp->flag=0;
         temp->length=t->length-length_p;
         temp->address=t->address+length_p;
         t->name=name;
         t->flag=1;
         t->length=length_p;
         temp->next=t->next;
         t->next=temp;
     }
     else  //直接分配
     {
         t->name = name;
         t->flag = 1;       
     }   
 }