王道操作系统学习笔记(2)——进程管理

门牙会稍息

已于 2023-06-25 09:08:13 修改

阅读量651

点赞数 2

分类专栏：操作系统笔记文章标签：学习笔记操作系统

于 2023-06-25 09:06:52 首次发布

本文链接：https://blog.csdn.net/weixin_56646002/article/details/131367608

版权

操作系统笔记专栏收录该内容

3 篇文章 0 订阅

订阅专栏

前言

本文介绍了操作系统中的进程管理，文章中的内容来自B站王道考研操作系统课程，想要完整学习的可以到B站官方看完整版。

二：进程管理

2.1.1：进程的概念、组成、特征

程序：是静态的，就是存放在磁盘里的可执行文件，就是一系列的指令集合

进程：是动态的，是程序的一次执行过程。同一个程序多次执行会对应多个进程

进程控制块：一个进程中分配了哪些资源、运行情况等信息都会保存在一个数据结构PCB（进程控制块）中，是进程存在的唯一标志，供操作系统使用。

PCB中所包含的信息：

程序段、数据段、PCB三部分组成了进程实体

进程是进程实体的运行过程，是系统进行资源分配和调度的独立单位，一个进程被调度就是指操作系统决定让这个进程到CPU上运行

2.1.2：进程的状态（运行态、就绪态、阻塞态）与转换、进程的组织

阻塞态：在进程运行过程中，可能会请求等待某个事件的发生（如等待某种系统资源的分配，或者等待其他进程的响应）。在这件事发生之前，进程无法继续往下执行，此时操作系统会让这个进程下CPU，并让他进入“阻塞态”。

终止态：一个进程可以执行exit系统调用，请求操作系统终止该进程。此时该进程会进入“终止态”，操作系统会让该进程下CPU，并回收内存空间等资源，最后还要回收该进程的PCB。

五种状态的切换：

Linux中进程的状态分类：就绪态、运行态、僵尸态、停止态、可中断睡眠状态、不可中断睡眠状态

就绪态（Ready）：指该进程满足被 CPU 调度的所有条件但此时并没有被调度执行，只要得到 CPU就能够直接运行；意味着该进程已经准备好被 CPU 执行，当一个进程的时间片到达，操作系统调度程序会从就绪态链表中调度一个进程
运行态：指该进程当前正在被 CPU 调度运行，处于就绪态的进程得到 CPU 调度就会进入运行态；

Zombie（僵尸状态）：进程已经结束，但是其父进程还没有调用wait()函数来获取其退出状态，此时进程成为僵尸进程。

Stopped（停止状态）：进程被暂停，例如通过Ctrl+Z命令将进程挂起

Interruptible sleep（可中断睡眠状态）：进程正在等待某个事件的发生，例如等待输入输出完成或者等待信号量，此时进程可以被中断。

Uninterruptible sleep（不可中断睡眠状态）：进程正在等待某个事件的发生，例如等待磁盘I/O操作完成，此时进程不可被中断。

2.1.3：进程通信（共享存储、消息传递、管道通信）

共享存储

共享存储（在内存中开辟一段区域供进程间交换数据，实际是会生成一个文件，在/dev/shm目录下）shm_open、mmap两个函数来实现相关功能，下面通过两个读写文件来展示相关的用法。

write.c：

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdio.h>
#include <sys/mman.h>
#include <string.h>
#include <errno.h>
#include <unistd.h>
 
#define MMAP_DATA_SIZE 1024
 
int main(int argc,char* argv[])
{
        char* data;
        int fd = shm_open("shm1", O_CREAT|O_RDWR, 0777);
 
        if (fd < 0) {
                printf("shm_open failed!\n");
                return -1;
        }
 
        ftruncate(fd, MMAP_DATA_SIZE);
        data = (char*)mmap(NULL, 1024, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);
        if (!data) {
                printf("mmap failed\n");
                close(fd);
        }

        sprintf(data, "This is a share memory! %d\n", fd);

        munmap(data, MMAP_DATA_SIZE);
 
        close(fd); 
        return 0;
}

read.c:

#include <stdio.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>
#include <string.h>
#include <sys/mman.h>
#include <stdlib.h>
#include <linux/input.h>
#include <pthread.h>
#include <unistd.h>
#include <sys/mman.h>      
#include <fcntl.h> 

#define  MAP_FILE_SIZE 1024
int main(int argc, char* argv[])
{
    char *data;
    int fd = shm_open("shm1", O_RDONLY, 0777);
    if(fd < 0){
        perror("shm01 open error");
    }
    data = mmap(NULL, MAP_FILE_SIZE, PROT_READ, MAP_SHARED, fd, 0);
    if(data == MAP_FAILED){
        perror("data error");
    }
    printf("open read.c\r\n");
    printf("%s\r\n", data);
    munmap(data, MAP_FILE_SIZE);
    close(fd);

}

两程序的执行结果如下

open和shm_open的主要区别在于它们打开的对象不同，open打开的是普通文件，而shm_open打开的是共享内存对象。

消息传递

消息 = 消息头（发送进程ID、接收进程ID、消息长度）、消息体

消息队列

P通过发送原语send（）发送，Q通过接收原语receive（）将PCB消息队列的重大的msg拷贝到自己的的地址空间

管道通信

无名管道：匿名管道是一种无名的管道，只能用于父子进程之间或者兄弟进程之间的通信

代码示例

#include <stdlib.h>
#include <sys/wait.h>
#include <sys/stat.h>


int main(int argc, char *argv[])
{
    //自己写数据到管道，然后从管道中读数据，最后将数据写到标准输出上，终端打印hello
    
    int fd[2];
    int pp = pipe(fd);
    char buf[100];
    for(int i = 0; i < 10; i++){
        write(fd[1], "hello", 5);
        sleep(1);
        int r = read(fd[0], buf, 128);
        write(1, buf, r);
        printf("\r\n");
    }
    close(fd[0]);
    close(fd[1]);
    
    
    //父进程写东西到管道，子进程从管道中读数据，然后打印到终端上
    
    int fd[2];
    int pp = pipe(fd);
    char buf[100];
    if(fork() == 0){
        close(fd[1]);
        for(int i = 0; i < 3; i++){
            int r = read(fd[0], buf, 128);
            //printf("lseek  = %ld\r\n", lseek(fd[0], 0, SEEK_CUR));
            write(1, buf, r);
            printf("\r\n");
        }
        close(fd[0]);
        _exit(0);
    }
    else{
        close(fd[0]);
        for(int i = 0; i < 3; i++){
            write(fd[1], "hello", 5);
            sleep(1);
        }
        wait(NULL);
        close(fd[1]);
        exit(0);
    }
    

}

有名管道：命名管道是一种有名的管道，可以用于任意进程之间的通信

创建有名管道：

    int ret = mkfifo("/tmp/lcdpipe", 0777);
    if(ret < 0){
        perror("!!mkfifo!!");
    }

有名管道读端等待：

 if(fork() == 0){
        //通过管道来接收要执行程序命令，然后执行
        char rec_buf[100];
        int fd = open("/tmp/lcdpipe", O_RDWR);
        read(fd, rec_buf, sizeof(rec_buf));
        printf("receive message\r\n");
        system(rec_buf);
    }

有名管道写端：

 //发送命令回到主界面
            else if((ts_y > 0 && ts_y < 100) && (ts_x > 0 && ts_y <100)){
                char temp2[30]; 
                char command2[30];
                int pid = getpid();
                sprintf(temp2, "%d", pid);
                sprintf(command2, "kill -9 %s", temp2);

                int fd = open("/tmp/lcdpipe", O_RDWR);
                char send_buf[100] = "cd /mnt/udisk && ./mainWindowApp";
                write(fd, send_buf, sizeof(send_buf));
                printf("send message\r\n");
                system(command2);
            }

Linux中的共享内存和管道通信都是进程间通信的方式，但它们之间有以下区别：

1. 共享内存是一种进程间通信的方式，它允许多个进程访问同一块内存区域，而管道通信是一种单向的进程间通信方式，只能在一个方向上传递数据。

2. 共享内存是通过将一段内存区域映射到多个进程的地址空间中来实现的，而管道通信是通过创建一个管道文件来实现的。

3. 共享内存的数据可以直接在内存中进行读写，速度较快，而管道通信需要将数据从一个进程的缓冲区复制到另一个进程的缓冲区中，速度较慢。

2.1.4：线程的概念

线程是一个基本的CPU执行单位，也是程序执行流的最小单位。进程只作为除CPU之外的系统资源的分配单位。

引入线程后的变化

1：系统资源的分配和调度

传统进程机制中，进程是资源分配和调度的的基本单位。引入线程之后进程是资源分配的基本单位，线程是调度的基本单位。

2：并发性

传统进程机制中只能进程间并发，引入线程后，各线程之间也能并发，提升了并发度。

3：系统开销

传统进程间并发，需要切换进程的运行环境，系统开销大。线程间并发，如果是同一进程内的线程切换，则不需要切换进程环境，系统开销小。

线程属性

2.1.5：线程的状态与转换（TCB）

线程控制块：

线程表：

2.2.1：调度的概念和层次（作业、调度的层次、挂起）

调度的核心理念就是当有一堆任务要处理，但由于资源有限，这些事情没法同时处理。这就需要确定某种规则来决定处理这些任务的顺序。

高级调度（作业调度）

按一定的原则从外存的作业后备队列中挑选一个作业调入内存，并创建进程。每个作业只调入一次，调出一次。作业调入时会建立PCB，调出时才撤销PCB。

中级调度（内存调度）

内存不够时，可将某些进程的数据调出外存。等内存空间或者进程需要运行时再重新调入内存。暂时调到外存等待的进程状态为挂起状态。被挂起的进程PCB会被组织成挂起队列

中级调度：按照某种策略决定将哪个处于挂起状态的进程重新的调入内存

低级调度（进程调度）

按照某种策略从就绪队列中选取一个进程，将处理机分配给他

挂起和阻塞的区别：两种状态都是暂时不能获得CPU服务，但挂起状态是将进程映像调到外存去了，而阻塞态下进程映像还在内存中。阻塞态是进程主动等待某个事件的发生，而挂起态是进程被动被中止执行。

三层调度的联系和对比

2.2.2：进程调度的时机和方式（内核临界区、普通临界区、调度时间、抢占式、进程切换）

需要进行进程调度和切换的情况（主动放弃和被迫放弃）

不能进行进程切换的情况（处理中断、临界区、原子操作）

内核临界区访问临界资源之前会上锁，如果不尽快释放的话，极有可能影响到操作系统内核的其他管理工作。因此在访问内核程序临界区期间不能进行调度和切换。普通临界区访问的临界资源不会直接影响操作系统内核的管理工作。因此在访问普通临界区的时候可以进行调度和切换。

非抢占式：只允许进程主动放弃处理机，在运行过程中即便有更紧迫的任务到达，当前进程依然会继续使用处理机，直到该进程终止和主动要求进入阻塞态。

抢占式：当一个进程正在处理机上执行时，如果有一个更重要或更紧迫的进程需要使用处理机，则立即暂停正在执行的过程，将处理机分配给更重要紧迫的那个进程。

进程切换：是指一个进程让出处理机，由另一个进程占用处理机的的过程。进程切换主要完成了对原来运行进程的各种数据保存，对新的进程各种数据的恢复。（如：程序计数器、程序状态字等，这些信息一般保存在进程控制块PCB中）

2.2.3：调度器和闲逛进程

当没有其他就绪进程时，调度程序就会运行闲逛进程（idle）

2.2.4：调度算法的评价指标（CPU利用率、系统吞吐量、周转时间、等待响应时间）

CPU利用率：CPU“忙碌”的时间占总时间的比例

系统吞吐量：单位时间内完成的作业数量

周转时间：是指从作业被提交给系统开始，到作业完成为止的这段时间间隔

周转时间包括四部分：作业在外存后备队列上等待作业调度（高级调度）的时间+进程在就绪队列上等待进程调度（低级调度）的时间+进程在CPU上执行的时间+进程等待I/O操作完成的时间

2.2.5：调度算法（FCFS、SJF、HRRN、时间片轮转、优先级调度）

1、先来先服务：

饥饿现象：某进程/作业长期得不到某种资源或服务

FCFS的优缺点：对长作业有利，对短作业不利（食堂打饭时前面有个人给全宿舍的人带饭）

2、短作业优先算法：

追求最少的平均等待时间，最少的平均周转时间

3、高响应比优先算法：

要综合考虑作业/进程的等待时间和要求服务的时间

响应比 = （等待时间 + 要求服务的时间）/ 要求服务的时间

4、时间片轮转：

公平地、轮流地为各个进程服务，让每个进程在一定时间间隔内都可以得到响应。如果时间片太大，使得每个进程都可以在一个时间片内就完成，则时间片轮转调度算法退化为先来先服务调度算法，并且会增大进程响应时间。另一方面如果时间片太小，进程调度和切换有时间代价的（保存、恢复运行环境），如果时间片太小，会导致进程切换过于频繁，系统会花大量的时间来处理进程切换，从而导致实际用于进程执行的时间比例减小。