ios 用户单例单用户单任务os

转载

mob6454cc62b754 2023-07-23 22:46:18

文章标签 ios 用户单例推荐算法互斥算法思想磁道 文章分类 iOS 移动开发

OS具有的四大特征：并发，共享，虚拟，异步。

微机OS按运行方式分为：单用户单任务OS：一个用户上机，只允许用户程序作为一个任务运行；

单用多单任务OS：一个用户上机，允许用户把程序分为若干个任务并发执行；

多用户多任务OS：允许多个用户通过各自的终端使用一台机器，每个用户程序又可以分为若干个任务并发执行。

原语：由若干条指令组成，用于完成一定功能的一个过程，在执行过程中不允许被中断。

原子操作：一个操作中的所有动作要么全做，要么全不做，它是一个不可分割的基本单位，

原子操作在内核态下执行，常驻内存。

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

周转时间=作业完成时刻-作业到达时刻

带权周转时间=周转时间/服务时间

平均周转时间=作业周转总时间/作业个数

平均带权周转时间=带权周转总时间/作业个数

高级调度：对象是作业；

低级调度：对象是进程（或内核级线程）；

中级调度：提高内存利用率和系统吞吐量。

前趋图

进程：是一段可并发执行的具有独立功能的程序，是关于某个数据集的一次执行过程，也是OS进行资源分配和保护的基本单位。

引起创建进程的典型事件：用户登录、作业调度、提供服务、应用请求

运行态：进程占有处理机，正在运行。

就绪态：进程具备运行条件，等待系统分配处理机以便运行。

等待态（阻塞态、睡眠态）：进程不具备运行条件，正等待某个事件完成。

挂起状态：是一种静止的状态，一个进程被挂起后，不管它是否处于就绪状态，系统都不会分配给它处理机

ios 用户单例单用户单任务os_互斥

线程：是一个轻型实体，是可独立调度和分派的基本单位，可并发执行，可共享所属进程的资源，引入线程是为了减少进程在并发执行时所付出的时空开销，使OS具有更好的并发性。

管程：由代表共享资源的数据结构以及由对该共享数据结构实施操作的的一组过程所组成的资源管理程序共同构成的一个OS资源管理模块

临界区：进程中访问临界资源的那段代码

临界资源：一次仅允许一个进程使用的资源（打印机和共享变量）

同步机制遵循的准则：

1.空闲让进

2.忙则等待

3.有限等待（防止饥饿现象）

4.让权等待（进程不能进入临界区的时候要释放CPU）

实现同步区互斥的基本方法：

软件方法：

1.单标志法

2.双标志先检查法

3.双标志后检查法

4.Peterson算法

硬件方法：

1.中断屏蔽方法（关中断，降低了系统的效率）

2.硬件指令方法

死锁：多个进程在运行过程中争夺资源而造成的一种僵局，当进程处于这种僵持状态，若无外力作用，它们都无法向前推进。

死锁产生原因：1.竞争资源

2.进程推进顺序非法

死锁产生的必要条件：1.互斥条件

2.请求和保持条件

3.不可抢占条件

4.循环等待条件

信号量机制采用两个标准的==原语（P[wait()]V[signal()]操作）==来解决互斥同步的问题。对于PV操作的描述，在不同类型的型号量中实现的方法有所差异。

同步问题：1.生产者-消费者问题

Q：一组生产者进程和一组消费者进程共享一个初始为空、大小为n的缓冲区，只有缓冲区没满的时候，生产者才能写入数据，只有缓冲区不空的时候消费者才能取出数据，缓冲区是临界资源，同时只允许一个生产者或一个消费者放入消息。

A：互斥关系：任意两个进程之间都是互斥关系;

同步关系：生产者和消费者之间是同步关系，先生产才能进行消费

信号量的设置：设置一个mutex来作为互斥信号量，初始值为1，设置一个full来表示缓冲区中消息的数量，初始值为0，设置一个empty来表示缓冲区中空位的数量，初始值为n

semaphore mutex = 1;
semaphore full = 0;
semaphore empty = n;
//生产者
producer() {
while(1){
produce an item in nextp;
P(empty);//同步关系，分析进程执行顺序，想要什么P一下
P(mutex);//最靠近临界资源；直接夹住
访问缓冲区;
V(mutex);
V(full);//提供什么V一下
}
}
//消费者
consumer() {
while(1) {
P(full);
P(mutex);
取出数据；
V(mutex);
V(empty);
}
}

复杂情况：Q:桌上有个盘子，每次只能放一个水果。爸爸向盘子里放苹果，妈妈放橘子，儿子等着吃橘子，女儿等着吃苹果。

A：

互斥关系：爸爸妈妈对盘子互斥

同步关系：爸爸和女儿同步，妈妈和儿子同步

信号量设置：

设置一个互斥信号量plate = 1；apple = 0；orange = 0;
D:semaphore mutex = 1;
semaphore apple = 0;
semaphore orange = 0;
//本题中缓冲区大小为1，不需要用mutex夹紧，不设置互斥信号量
daa() {
while(1) {
P(plate);
放苹果；
//V(mutex);
V(apple);
}
}
mom() {
while(1) {
P(plate);
放橘子；
//V(mutex);
V(orange);
}
}
son() {
while(1) {
P(orange)
拿橘子
V(plate)
}
}
daughter() {
while(1) {
P(apple)
拿苹果
V(plate)
}
}

2.读者-写者问题

Q: 读者写者两组并发进程，共享一个文件，当两个以丄的读进程同时访问共享数据时不会发生副作用，但某个写进程和其他进程（包括读和写）同时访问共享数据时则出错。因此要求：①多个读者可以同时对文件进行读操作；②只允许一个写进程往文件中写信息；③任一写着在完成写操作前不允许其他读者写者工作；④写着执行操作前，应该让所有的读者和写者全部退出。（何解？抢夺？）

A: 互斥关系：读者和写者互斥，写者和写者互斥

同步关系：读者和写者同步

信号量设置：

mutex = 1; count = 0;
D:int count = 0;
semaphore mutex = 1;
//写者
writer() {
while(1) {
P(mutex);
写；
V(mutex);
}
}
//读者
reader() {
while(1) {
//下面的操作无法一气呵成，所以需要增加一个互斥信号量锁住，让其成为一个原子操作
P(mutex_r);
if(count == 0) P(mutex);
count ++;
V(mutex_r);
读；
P(mutex_r);
count --;
if(count == 0) V(mutex);
V(mutex_r);
}
}
改进：
int count = 0;
semaphore mutex = 1;
semaphore mutex_r = 1;
semaphore mutex_w = 1;
//写者
writer() {
while(1) {
P(mutex_w);
P(mutex);
写；
V(mutex);
V(mutex_w);
}
}
//读者
reader() {
while(1) {
P(mutex_w);
P(mutex_r);
if(count == 0) P(mutex);
count++;
V(mutex_r);
V(mutex_w);
读；
P(mutex_r);
count--;
if(count == 0) V(mutex);
V(mutex_r);
}
}
3.哲学家进餐问题
Q: 五个哲学家，两个之间一根筷子，两根筷子之间一碗饭，哲学家饥饿时，试图拿起左右两根筷子，筷子在别人手上就等待，只有同时拿到两根筷子才能进餐。
A: 互斥关系：五个进程对左右邻居之间的筷子互斥。
   信号量设置：设置互斥信号量组chopstick[5]={1，1，1，1，1}
D:semaphore mutex = 1;
semaphore chopsticks[5] = {1, 1, 1, 1, 1};
P1() {
do() {
P(mutex);//让拿左右筷子的操作一气呵成~不然会死锁的呢
P(chopsticks[i]);
P(chopsticks[(i+1)%5]);
V(mutex);
恰饭
P(mutex);
V(chopsticks[i]);
V(chopsticks[(i+1)%5]);
V(mutex);
}while(1);
}

进程调度：

1.先来先服务（FCFS）

算法思想：进程按照它们请求CPU的顺序使用CPU.就像你买东西去排队，谁第一个排，谁就先被执行，在它执行的过程中，不会中断它。

算法评价：易于理解且实现简单，只需要一个队列(FIFO)，且相当公平,比较有利于长进程，而不利于短进程，有利于CPU 繁忙的进程，而不利于I/O 繁忙的进程

2.最短作业优先（SJF）

算法思想：对预计执行时间短的进程优先分派处理机

算法评价：相比FCFS 算法，该算法可改善平均周转时间和平均带权周转时间，缩短进程的等待时间，提高系统的吞吐量，对长进程非常不利，可能长时间得不到执行，且未能依据进程的紧迫程度来划分执行的优先级，以及难以准确估计进程的执行时间，从而影响调度性能。

3.优先级调度

a.抢占式

b.非抢占式

4.最高响应比优先（HRRN）

算法思想：HRN调度策略同时考虑每个作业的等待时间长短和估计需要的执行时间长短，从中选出响应比最高的作业投入执行。这样，即使是长作业，随着它等待时间的增加，W / T也就随着增加，也就有机会获得调度执行。

算法评价：由于长作业也有机会投入运行，在同一时间内处理的作业数显然要少于SJF法，从而采用HRRN方式时其吞吐量将小于采用SJF 法时的吞吐量，由于每次调度前要计算响应比，系统开销也要相应增加。

5.时间片轮转（RR）

算法思想：让就绪进程以FCFS 的方式按时间片轮流使用CPU 的调度方式，即将系统中所有的就绪进程按照FCFS 原则，排成一个队列，每次调度时将CPU 分派给队首进程，让其执行一个时间片，时间片的长度从几个ms 到几百ms。在一个时间片结束时，发生时钟中断，调度程序据此暂停当前进程的执行，将其送到就绪队列的末尾，并通过上下文切换执行当前的队首进程，进程可以未使用完一个时间片，就出让CPU（如阻塞）

算法评价：时间片轮转调度算法的特点是简单易行、平均响应时间短，不利于处理紧急作业。在时间片轮转算法中，时间片的大小对系统性能的影响很大。

时间片大小的确定：
1.系统对响应时间的要求
2.就绪队列中进程的数目
3.系统的处理能力

页面置换算法：

1.最佳置换算法（OPT）

算法思想：每次选择淘汰的页面将是以后永不使用，或者在最长时间内不再被访问的页面，这样可以保证最低的缺页率。

算法评价：最佳置换算法可以保证最低的缺页率，但是实际上，只有进程执行的过程中才能知道接下来会访问到的是哪个页面。操作系统无法提前预判页面的访问序列。因此，最佳置换算法是无法实现的。

ios 用户单例单用户单任务os_磁道_02

2.先进先出置换算法（FIFO）

算法思想：每次选择淘汰的页面是最早进入内存的页面。

算法评价：当为进程分配的物理块数增大时，缺页次数不减反增的异常现象称为贝莱迪（Belay）异常。只有FIFO算法会产生Belay异常。另外，FIFO算法虽然实现简单，但是该算法与进程实际运行时的规律不适应。因为先进入的页面也有可能最经常被访问。因此，算法性能差。

3.最近最久未使用置换算法（LRU）

算法思想：每次淘汰的页面是最近最久未使用的页面。

算法评价：性能很好，但是需要硬件支持，算法开销大

4.简单时钟算法

算法思想：算法思想：为每个页面设置一个访问位，再将内存中的页面都通过链接指针链接成一个循环队列。当某个页被访问时，其访问位置1.当需要淘汰一个页面时，只需检查页的访问位。如果是0，就选择该页换出；如果是1，暂不换出，将访问位改为0，继续检查下一个页面，若第一轮扫描中所有的页面都是1，则将这些页面的访问位一次置为0后，再进行第二轮扫描（第二轮扫描中一定会有访问位为0的页面，因此简单的CLOCK算法选择一个淘汰页面最多会经过两轮扫描）

算法评价：实现简单，算法开销小，但是未考虑页面是否被修改过

5.改进时钟算法

算法思想：在其他在条件相同时，应该优先淘汰没有被修改过的页面，从而来避免I/O操作。

算法评价：算法开销小，性能也不错

磁盘调度：

1.先来先服务算法（FCFS）

算法思想：根据进程请求访问磁盘的先后顺序进行调度

算法评价：公平；如果请求访问的磁道比较集中的话，算法性能还算可以，如果大量进程竞争使用磁盘，请求访问的磁道很分散，FCFS在性能上很差，寻道时间长。

ios 用户单例单用户单任务os_算法思想_03