操作系统（三）| 进程管理下 经典进程问题分析 线程 死锁

6.经典进程同步问题

6.1 生产者-消费者问题 (既有同步又有互斥)

生产者往缓冲区写数据，满了的话就不能写了

消费者从缓冲区取数据，空的话就不能取了

一次只能有一个生产者或消费者取读数据

总结要求

（1）不能向满的缓存区写数据

（2）不能向空的缓存区取数据

（3）任何时刻，仅允许一个1个生成者或1个消费者访问

​ 意味着消费者之间互斥，生成者之间互斥，消费者和生产者之间互斥

full：记录缓冲区中非空的槽数，初始值=0

empty：记录缓冲区中空的槽数，初始值=N

mutex：确保进程不同时访问缓冲区，初始值=1

解决（1）（2）

void producer(void){
	while (True) {
        produce(); //生产1项
        P(empty); //申请1个空槽
        P(mutex); //请求进入临界区
        append(); //加入缓冲区
        V(mutex); //离开临界区
        V(full); //递增非空槽
    }
}

void consumer(void){
    while (TRUE) {
        P(full); //申请1个非空槽
        P(mutex); //申请进入临界区
        remove(); //从缓冲区移出1项
        V(mutex); //离开临界区
        V(empty); //递增空槽数
        consume(); //消费数据
    }
}

	

解决死锁问题

6.2 读者-写者问题

多个Reader进程，多个Writer进程，共享文件F
要求：
允许多个Reader进程同时读文件
不允许任何一个Writer进程与其他进程同时访问（读或写）文件

我的方案

read_count=N 初始值N，空额的值

write_count=0

void reader(void){
	while (True) {
		P(read_count)
       if(writer==0)
       		read();//读操作
       	V(read_count)
        P(write_count)
        	read();
       	V(write_count)
       
    }
}

void writer(void){
    while (True) {
    	P(write_count)
        	write();
       	V(write_count)
    }
}

标答

write

WriteMutex = 0 读写操作的互斥访问
Rcoun = 0 正在读操作的读者数目
CountMutex = 0 读者计数的互斥访问

void reader(void){
	while (True) {
		P(CountMutex);
  		if (Rcount == 0)
     		P(WriteMutex);
     		++Rcount;
		V(CountMutex);
     	read;
		P(CountMutex);
 		--Rcount;
      	if (Rcount == 0)
     		V(WriteMutex);
		V(CountMutex);

       
    }
}

void writer(void){
    while (True) {
    	P(WriteMutex);
        write;
    	V(WriteMutex);

    }
}

6.3 哲学家进餐问题

6.4理发师问题

注意对于共享变量，一定要加PV临界操作

7. 进程之间通信

P,V操作实现的是进程之间的低级通信，所以P,V操作是低级通讯原语，即不能传递大量的信息

所以我们引入进程间高级通讯方式

7.1 共享存储区

相互通信的进程间设有公共的内存区，每个进程既可向该公共内存中写，也可从公共内存中读，通过这种方式实现进程间的信息交换。
把同一个物理内存区域同时映射到多个进程的内存地址空间的通信机制

7.2 消息传递

源进程发送消息，目的进程接受消息。所谓消息，就是一组数据。

（1）消息队列（message Queue）或消息缓冲
发送者发消息到一个消息队列中；
接收者从相应的消息队列中取消息。
消息队列所占的空间从系统的公用缓冲区中申请得到。
（2）邮箱（mailbox）
发送者发消息到邮箱，接收者从邮箱取消息。
邮箱是一种中间实体，一般用于非实时通信。

7.3 管道

首创于Unix。用于连接一个读进程、一个写进程，以实现它们之间通信的共享文件，称为pipe文件。

管道分为下列2种：
有名管道
无名管道

8.线程

为什么引入线程

线程是进程的１条执行路径。

1个进程可以有多个线程，其中至少有1个主线程（primary thread）。

1个进程内的多个线程在同一个地址空间内（共享该进程的地址空间）。

每个线程有自己的线程控制块TCB（Thread Control Block），包含自己的堆栈和状态信息。TCB比PCB小得多。

8.1 线程的实现机制

用户级线程

​ 由在用户空间执行的线程库来实现，OS对此一无所知。　
线程库提供线程创建、撤消、上下文切换、通信、调度等功能。

​ 用户级线程是自己实现的线程创建，删除

​ 但是这样的话操作系统分配的是进程为单位的，容易阻塞

​ 但是性能高，无需陷入内核

核心级线程

​ 用户级线程是自己实现的线程创建，删除

​ 但是这样的话操作系统分配的是线程为单位的

​ 但是性能低，需要陷入内核

进程和线程是操作系统中用于实现并发执行的两个基本概念，它们之间有许多重要区别，包括以下几点：

1. 定义：

   • 进程（Process）是一个独立的执行单元，拥有独立的内存空间和系统资源，它代表了一个正在运行的程序的实例。每个进程都有自己的地址空间，堆栈和数据段，相互之间不共享这些资源。
   • 线程（Thread）是进程内的一个轻量级执行单元，线程共享进程的地址空间和系统资源，包括堆栈和文件描述符。多个线程可以在同一进程中并发执行，它们之间共享相同的内存空间。

2. 创建和销毁开销：

   • 进程的创建和销毁通常比较耗费系统资源，因为每个进程都有独立的内存空间，需要进行全新的资源分配和销毁。
   • 线程的创建和销毁相对较轻量，因为它们共享进程的资源。创建一个线程通常比创建一个新进程要快速和经济。

3. 通信：

   • 进程之间通信通常需要使用进程间通信（Inter-Process Communication，IPC）机制，例如管道、消息队列、共享内存等，来传递数据和信息。
   • 线程之间通信可以更容易地实现，因为它们共享相同的内存空间。线程可以通过共享变量等方式直接进行通信。

4. 并发性和并行性：

   • 进程通常具有更高的并发性，因为不同进程之间相互独立，可以在不同的处理器上并行执行。多进程可以更好地利用多核处理器。
   • 线程在同一进程内并发执行，它们共享进程的资源，因此在多核处理器上并行执行的程度有限。但线程之间的切换比进程切换更快，因为不涉及进程资源的切换。

5. 安全性：

   • 由于线程共享进程的内存空间，因此多个线程之间的错误可能更容易导致进程崩溃或数据损坏。
   • 进程之间的安全性更高，因为它们拥有独立的内存空间，一个进程的错误通常不会影响其他进程。

6. 编程模型：

   • 多进程编程相对较复杂，因为需要处理进程间通信和同步问题。
   • 多线程编程相对较简单，因为线程之间共享数据，但需要小心处理共享资源的同步问题。

9 进程调度

为什么进程调度

多个进程就绪时候，OS决定先执行哪一个

我们进程调度要达到的目的

​ CPU利用率高，吞吐量大，周转时间少，等待时间短，公平

​ 很多时候都是在权衡！很多时候很难兼顾所有的目的

什么时候会切换进程呢？

​ 硬件中断，进程异常，或者该进程请求IO，这些都会让CPU闲下来，我们就要给CPU找活干了

一些概念

• 周转时间 = 作业完成时刻 - 作业到达时刻
• 带权周转时间 = 周转时间 / 服务时间
• 平均周转时间 = 作业周转总时间 / 作业个数
• 平均带权周转时间 = 带权周转总时间 / 作业个数

9.1 调度方式

非抢占方式

​ 一旦某进程被调度，直到完成或因某事件而阻塞，才会切换到其他进程

抢占方式

​ 允许暂停正在运行的进程，切换到其他进程

抢占原则：

​ 时间片原则：时间片到时抢占

​ 优先级原则：优先级高者到时抢占

9.2 常见算法

先来先服务 FCFS

按照进程就绪的先后次序来调度进程，非抢占式方式

优点：实现简单

缺点:
（1）平均等待时间波动很大
短进程、长进程到达时间是随机的
（2）有利于CPU繁忙型进程，不利于I/O繁忙型进程
（3）有利于长进程，不利于短进程

短进程优先 SPN

最高相应比优先算法

时间片轮转 RR

将所有的就绪进程按FCFS原则排成一个队列，
规定一个时间片为进程每次使用CPU的最长时间，
每次选择队首进程运行，
当时间片到时，剥夺该进程的运行，将其排在队尾

基于优先级的调度

多级反馈队列

10 死锁

10.1 基本概念

死锁

一个进程集合中的每个进程都在等待只能由该集合中的其它进程才能引发的事件，这种状态称作死锁。一组竞争系统资源的进程由于相互等待而出现“永久”阻塞。

例如，2个进程A、B，都需要资源R1、R2

若A：拥有R1，申请R2

若B：拥有R2，申请R1

如何？

资源分类

可重用资源

资源不能被删除且在任何时刻只能有一个进程使用

进程释放资源后，其他进程可重用

消耗资源

10.2 如何处理死锁

由OS处理

​ 检测死锁并恢复

​ 分配资源时避免死锁

​ 假装没看见（鸵鸟策略）：多数OS对待死锁的策略

​ 死锁了怎么办，开机重启

由应用程序本身预防死锁

​

实际中检测死锁恢复是可能的，但是代价太大

10.2.1 死锁检测

E[M]：总资源数；E[i]：资源i的个数

A[M]：当前可用资源数；A[i]：资源i的可用数

C[N][M]：当前分配矩阵；C[i][j]：进程i对资源j的占有数

​ 第i行是进程i当前占有的资源数

R[N][M]：申请矩阵；R[i][j]：进程i对资源j的申请数

​ 第i行是进程i申请的资源数

F[N]：进程标记；F[i]取0/1，为1表示进程i能够执行

算法

​ 看当前是否有进程可以执行，可以执行的话，该进程F[N]设置为1，同时释放他的资源

​ 依次进行

​ 两种情况

​ 一， 所有进程都可以执行，则不死锁

​ 二，存在某一种情况所有的进程都无法执行，则死锁

10.2.2 何时检测

1）每当有资源请求时；

2）周期性检测；

3）每当CPU的使用率降到某一阈值时。

死锁检测会占用大量的CPU时间