进程与线程

一、同步与互斥

【2016统考】进程P1和P2均包含并发执行的线程，部分伪代码描述如下。

下列选项中，需要互斥执行的操作是（）

A、a = 1 与 a = 2        B、a = x 与 b = x         C、x+=1 与 x+=2        D、x += 1 与 x += 3

解析：

D、P1和P2中的x属于不同范围的x，互不影响；

C、同一进程内的x会相互影响，所以x+=1、x+=2的不互斥执行会导致x有不同的值；

B、a = x，b = x即使不互斥也不会影响最后的结果，一个改变a，一个改变b

A、a = 1，a = 2，赋值不影响结果

【2009统考】三个进程P1，P2，P3互斥使用一个包含N（N>0）个单元的缓冲区。P1每次用produce()生成一个正整数并用put()送入缓冲去某一个空单元；P2每次用getodd()从该缓冲区取出一个奇数并用countodd()统计奇数个数；P3每次用geteven()从该缓冲区取出一个偶数并用counteven()统计偶数个数。

用信号量机制实现这三个进程的同步者互斥活动，并说明所定义的信号量的含义

多消费者模型，消费者和生产者对临界区的访问是互斥的，但取奇数、取偶数与P1是同步的，P1生产了P2、P3才能取。

同步：奇数、偶数的同步信号量odd、even

互斥：缓冲区空位的个数N，互斥信号量mutex

semaphore mutex = 1;
semaphore odd = 0,even = 0;
semaphore empty = N;
cobegin{
P1()
    while(true){
    x = produce();
P(empty);
P(mutex);
Put();
V(mutex);
if(x%2)
    V(even);
else
    V(odd);

}
P2()
    while(true){
P(odd);
P(mutex);
    getodd();
V(mutex);
V(empty);
    countodd();
    }
P3()
    while(true){
P(even);
P(mutex);
    geteven();
V(mutex);
V(empty);    
    counteven();
    }
}

---

【2011统考】某银行提供1个服务窗口和10个供顾客等待的座位。顾客到达银行时，若有空座位，则到取号机上领取一个号，等待叫号。取号机每次仅允许一位顾客使用。当营业员空闲时，通过叫号选取一位顾客，并为其服务。顾客和营业员的活动过程描述如下：

cobegin{
process 顾客i
{
    从取号机获取一个号码;
    等待叫号;
    获取服务;
}
process 营业员
{
    while(TRUE)
    {
    叫号；
    为客户服务;
    }
}
coend

请添加必要的信号量和P，V[或wait()，signal()]操作，实现上述过程中的互斥与同步。要求写出完整的过程，说明信号量的含义并赋初值。

解析：

同步：空闲座位数N = 10，人数初值full = 0（空闲的座位数控制人能不能进，人数多少控制了窗口要不要开始）

互斥：取号机的使用mutex，营业员的服务service

semaphore N = 10;
semaphore mutex = 1;
semaphore full = 0;
semaphore service = 0;
cobegin{
process 顾客i
{   
    P(N);    
    P(mutex);
    从取号机获取一个号码;
    V(mutex);
    V(full);
    P(service);
    获取服务;
}
process 营业员
{
    while(TRUE)
    {
    P(full);//没有顾客则休息
    V(N);//离开座位
    V(service);//叫号
    为顾客服务；
    }
}
coend

---

【2013统考】某博物馆最多可容纳500人同时参观，有一个出入口，该出入口一次仅允许一人通过。参观者的活动描述如下：

cobegin{
参观者进程i{
……
进门。
……
参观：
……
出门：
……
}
}coend

互斥：出入口的使用mutex = 1

同步：馆内的空位empty = 500

cobegin{

semaphore mutex = 1;

semaphore full = 0;

semaphore empty = 500;

参观者进程i{

P(empty);

P(mutex);

进门；

V(mutex);

参观；

P(mutex);

出门；

V(mutex);

V(empty);

……

}coend

---

【2014统考】系统中有多个生产者进程和多个消费者进程，共享一个能存放1000件产品的环形缓冲区。缓冲区未满时，生产者进程可以放入其生产的一件产品，否则等待；缓冲区未空时，消费者进程可从缓冲区取走一件产品，否则等待。要求一个消费者进程从缓冲区连续取出10件产品后，其他消费者进程才可以取产品。请使用信号量P，V操作实现进程间的互斥与同步。

互斥：缓冲区的访问需要互斥锁mutex=1

同步：产品的数量full = 0，还能放多少产品empty = 1000

cobegin{

semaphore mutex1 = 1,mutex2 = 1;

//mutex1用来控制消费者能连续取10个，不会被别的消费者进程破坏

semaphore full = 0;

semaphore empty = 1000;

Producer i{

        P(empty);

        P(mutex2);

放入缓冲区；

        V(mutex2);

        V(full);

}

Consumer i{

int x = 10;

        P(mutex1);

while(x--){

        P(full);

        P(mutex2);

从缓冲区中取出一件产品；

        V(mutex2);

        V(empty);

        }

        V(mutex1);

}

}coend

---

【2015统考】有A，B两人通过信箱进行辩论，每个人都从自己的信箱中取得对方的问题。将答案和向对方提出的新问题组成一个邮件放入对方的邮箱中。假设A的信箱最多放M个邮件，B的信箱最多放N个邮件。初始时A的信箱中有x个邮件（0

当信箱不为空时，辩论者才能从信箱中取邮件，否则等待。当信箱不满时，辩论者才能将新邮件放入信箱，否则等待。

信箱A的邮件数fullA = x ，信箱B的邮件数fullB = y；信箱A还能存的邮件数emptyA = M，信箱BemptyB = N；对信箱A的访问互斥mutex1 = 1，对信箱B的访问互斥mutex2 = 1.

semaphore fullA = x, fullB = y;

semaphore emptyA = M, emptyB = N;

semaphore mutex1 = 1 , mutex2 = 1;

cobegin{

A{

        P(fullA);

        P(mutex1);

回答问题；

        V(mutex1);

       V(emptyA);

        P(emptyB);

        P(mutex2);

放入邮件；

        V(mutex2);

        V(fullB);

}

B{

        P(fullB);

        P(mutex2);

回答问题；

        V(mutex2);

       V(emptyB);

        P(emptyA);

        P(mutex1);

放入邮件；

        V(mutex1);

        V(fullA);

}

}coend

---

【2017统考】某进程中有3个并发执行的线程thread1，thread2和thread3，其伪代码如下

解析：

互斥：y，z的互斥使用, mutex_y1 = 1, mutex_y2 = 1 , mutex_z = 1.

semaphore mutex_y1 = 1, mutex_y2 = 1 , mutex_z = 1;//y1用于thread1和thread3互斥，y2用于thread2和thread3互斥，thread1和thread2之间不存在互斥，若用一个互斥量则效率变慢

thread1{

        cnum w;

P(mutex_y1);

        w = add(x,y);

V(mutex_y1);  

}

thread2{

cnum w;

P(mutex_y2);

P(mutex_z);

        w = add(y,z);

V(mutex_z);

V(mutex_y2);  

}

thread3{

cnum w;

w.a = 1;

w.b = 1;

P(mutex_z);

        z = add(z,w);

V(mutex_z);

P(mutex_y1);

P(mutex_y2);

        y = add(y,w);

V(mutex_y1)

V(mutex_y2);

}

【2021统考】下表给出了整型信号量S的wait（）和signal（）操作的功能描述，以及采用开/关中断指令实现信号量操作互斥的两种方法。

1）s是多个进程共享的变量，多个进程都可以通过wait，signal进行读写操作。

2）方法1 不正确，方法2正确，若进入wait之后s如果小于等于0，则无法跳出循环，陷入死锁。

3）不能，开关中断指令属于特权指令，只能在内核区执行。

semaphore A = B = C = D = E = F = 0;

//线程之间的并发进行，不是要线程内的操作进行互斥同步

T1{

A;

signal(A);

wait(C);

E;

F;

}

T2{

B;

wait(A);

C;

signal(C);

D;

}

---

二、死锁

 1、安全性算法

解析：

A、Avail = Avail +  P1.Alloc = （2，2，1）  Avail < P2.Need 不合法

B、Avail = Avail + P1.Alloc = (2,2,1) Avail < P3.Need 不合法

……最后得到结论，安全序列不存在

tips:

计算安全序列：

1、先求need矩阵（尚需要分配）

2、将可用资源与need做比较，得到第一个need < avail (需要的 < 可用的）的进程 ，若不存在则不安全

3、将已分配的资源加到可用矩阵之中

4、重复步骤2

【2020统考】​​​​​​​某系统中有A、B两类资源各6个，t时刻的资源分配及需求情况如下表所示。

进程	A已分配数量	B已分配数量	A需求总量	B需求总量
P1	2	3	4	4
P2	2	1	3	1
P3	1	2	3	4

t时刻安全性检测结果（B）

A、存在安全性序列P1、P2、P3        B、存在安全性序列P2、P1、P3

C、存在安全性序列P2、P3、P1        D、不存在安全序列

解析：

，比较可用矩阵和需求矩阵，最接近的是P2，所以先选择P2 ，此时Available = [3,1]，选择P1，最后选择P3

2、死锁条件

【2014统考】某系统有n台互斥使用的同类设备，三个并发进程分别需要3、4、5台设备，可确保系统不发生死锁的设备数n最小为（B）

A、9 B、10 C、11 D、12

解析：

四个死锁条件缺一不可（循环等待，互斥使用，不剥夺，请求并保持）

现在缺少一个循环等待的条件：需要三者都同时等待对方释放设备。所以，只要满足一个进程的条件就不会发生死锁。所以，3 + 3 + 4 = 10台就不会发生死锁。

tips：想不发生死锁，只需破坏死锁条件

【2015统考】若系统S1采用死锁避免方法，S2采用死锁检测方法。下列叙述中，正确的是（B）

        1、S1会限制用户申请资源的顺序，而S2不会

        2、S1需要进程运行所需的资源总量信息，而S2不需要

        3、S1不会给可能导致死锁的进程分配资源，而S2会

A、仅1、2        B、仅2、3         C、仅1、3        D、1、2、3 

解析：

死锁避免：在分配资源时的保护措施，不分配给会导致死锁的进程

死锁检测：不采取任何操作，边分配边检测，发生死锁则立马采取措施解除死锁。S2中记录的是当前状态的资源，而非运行所需的资源总量信息

三、处理机调度

【2009】下列进程调度算法中，综合考虑进程等待时间和执行时间的是（D）

A、时间片轮转调度算法        B、短进程优先调度算法

C、先来先服务调度算法        D、高响应比优先调度算法

解析：

时间片轮转调度算法：给定时间片，在时间片内执行，时间片结束后立马结束

高响应比优先调度算法：响应比=（等待时间 + 要求服务时间）/ 要求服务时间，克服饥饿现象，满足短作业优先

【2012】一个多道批处理系统中仅有P1和P2两个作业，P2比P1晚5ms到达，它的计算和I/O操作顺序如下：

P1:    计算60ms，I/O 80ms，计算20ms

P2:    计算120ms，I/O 40ms，计算40ms

若不考虑调度和切换时间，则完成两个作业需要的时间最少是（B）

A、240ms       B、260ms        C、340ms        D、360ms

画甘特图

P1:        ｜——60——｜——80——｜              ｜—20—｜

P2:        ｜-5-｜          ｜————120————｜——40——｜——40——｜ 

所以需要260ms

【2016】某单cpu系统中有输入和输出设备各1台，现有3个并发执行的作业，每个作业的输入，计算和输出分别为2ms，3ms和4ms，且都按输入、计算和输出的顺序执行，则执行完3个作业需要的时间最少是（B）

A、15ms       B、17ms        C、22ms        D、27ms

｜-2-｜--3--｜---4---｜

           ｜-2-｜｜--3--｜ ｜---4---｜

                      ｜-2-｜     ｜--3--｜      ｜---4---｜

｜—2—3——4——————4—————4———｜=17ms

【2018】某系统采用基于优先权的非抢占式进程调度策略，完成一次进程调度和进程切换的系统时间开销为1us，在T时刻就绪对列中有三个进程P1，P2和P3，其在就绪对列中的等待时间，需要的CPU时间和优先权如下表所示。

进程	等待时间	需要的CPU时间	优先权
P1	30us	12us	10
P2	15us	24us	30
P3	18us	36us	20

若优先权值大的进程优先获得CPU，从T时刻系统开始进程调度，则系统的平均周转时间为（D）

A、54us        B、73us        C、74us        D、75us

｜1｜——24——｜1｜​​​​​​​————36————｜1｜——12——

t1 =  15 + 24 + 1= 40ms 

t2 = 36 + 24 + 2 + 18 = 80ms

t3 = 12 + 24 + 36 + 3 + 30 = 105ms

平均：（41 + 81 + 106 ）/ 3 =75us

【2020】下列与进程调度有关的因素中，在设计多级反馈对列调度算法时需要考虑的是（D）

1、就绪队列的数量                      2、就绪队列的优先级        

3、各就绪队列的调度算法        4、进程在就绪队列间的迁移条件

A、仅1、2        B、仅3、4        C、仅2、3、4        D、1、2、3和4

解析：就绪队列的数量会影响长进程的最终完成时间

【2016】某进程调度程序采用基于优先数的调度策略，即选择优先数最小的进程运行，进程创建时由用户指定一个nice作为静态优先数。为了动态调整的优先数，引入运行时间cpuTime和等待时间waitTime，初值均为0.进程处于执行态时，cpuTime定时加1，且waitTime置0；进程处于就绪态时，cpuTime置0，waitTime定时加1.

1）若调度程序只将nice的值作为进程的优先数，即priority = nice，则可能会出现饥饿现像，为什么？

2）使用nice，cpuTime和waitTime设计一种动态优先数计算方法，以避免产生饥饿现象，并说明waitTime的作用

1）就绪队列中，一直有优先级数小的进程，导致优先级大的进程一直无法进入执行态，从而产生饥饿现象。

2）priority = nice + cpuTime * k1 - waitTime * k2 + k3

waitTime越大代表在就绪队列中等待的时间越长，所以优先级会越高，从而避免饥饿现象