错题本第二章 进程管理

2021-01-30  本文已影响0人  NoelleMu

错题本第二章 进程管理

本文持续更新中

单项选择题

P39 5. 下面的叙述中，正确的是（）。

A. 进程获得处理器运行时通过调度得到的
B. 优先级是进程调度的重要依据，一旦确定不能改动
C. 在单处理器系统中，任何时刻都只有一个进程处于运行态
D. 进程申请处理器而得不到满足时，其状态变为阻塞态

P39 9. 一个进程释放了一台打印机，它可能会改变（）的状态。

A. 自身进程
B. 输入/输出进程
C. 另一个等待打印机的进程
D. 所有等待打印机的进程

P40 20. 若一个进程实体由PCB、共享正文段、数据堆段和数据栈段组成，请指出下列C语言程序中的内容及相关数据结构各位于哪一段中。

I. 全局赋值变量（）
II. 未赋值的局部变量（）
III. 函数调用实参传递值（）
IV. 用malloc()要求动态分配的存储区（）
V. 常量值（如1995、"string"）（）
VI. 进程的优先级（）

A. PCB
B. 正文段
C. 堆段
D. 栈段

P40 22. 系统动态DLL库中的系统线程，被不同的进程所调用，它们是（）的线程。

A. 不同
B. 相同
C. 可能不同，可能相同
D. 不能被调用

P41 30. 下列选项中，导致创建新进程的操作是（）。

I. 用户登录成功
II. 设备分配
III. 启动和程序执行

A. 仅I和II
B. 仅II和III
C. 仅I和III
D. I、II、III

P92 19. 用P，V操作实现进程同步，信号量的初值为（）。

A. -1
B. 0
C. 1
D. 由用户确定

P92 20. 可以被多个进程在任意时刻共享的代码必须是（）。

A. 顺序代码
B. 机器语言代码
C. 不允许任何修改的代码
D. 无转移指令的代码

P92 26. 一个进程因在互斥信号量mutex上执行V(mutex)操作而导致唤醒另一个进程时，执行V操作后mutex的值为（）。

A. 大于0
B. 小于0
C. 大于等于0
D. 小于等于0

P93 30. 下列关于管程的叙述中，错误的是（）。

A. 管程只能用于实现进程的互斥
B. 管程是由编程语言支持的进程同步机制
C. 任何时候只能有一个进程在管程中执行
D. 管程中定义的变量只能被管程内的过程访问

P96 46. 属于同一进程的两个线程thread1和thread2并发执行，共享初始值为0的全局变量x。thread1和thread2实现对全局变量x加1的机器代码描述如下：

thread1: 
mov R1, x       // (x) -> R1
inc R1          // (R1) + 1 -> R1
mov x, R1       // (R1) -> x

thread2:
mov R2, x       // (x) -> R2
inc R2          // (R2) + 1 -> R2
mov x, R2       // (R2) -> x

在所有有可能的指令执行序列中，使x的值为2的序列个数是（）。

A. 1
B. 2
C. 3
D. 4

P60 14. 下列调度算法中，（）调度算法是绝对可抢占的。

A. 先来先服务
B. 时间片轮转
C. 优先级
D. 短进程优先

P60 18. 有以下进程需要调度执行（见下表）：

  1. 若采用非抢占式短进程优先调度算法，问这5个进程的平均周转时间是多少？
  2. 若采用抢占式短进程优先调度算法，问这5个进程的平均周转周期是多少？

A. 8.62; 6.34
B. 8.62; 6.8
C. 10.62; 6.34
D. 10.62; 6.8

进程名 到达时间 运行时间
P1 0.0 9
P2 0.4 4
P3 1.0 1
P4 5.5 4
P5 7 2
image

可计算出平均周转时间为（9 + (16 - 0.4) + (10 - 1) + (20 - 5.5) + (12 - 7)）/ 5 = 10.62

抢占式短进程优先调度算法的广义甘特图如下：

image

可以计算出平均周转时间为（20 + 5 + 1 + 6 + 2）/ 5 = 6.8

P61 28. 若某单处理器多进程系统中有多个就绪态进程，则下列关于处理机调度的叙述中，错误的是（）。

A. 在进程结束时能进行处理机调度
B. 创建新进程后能进行处理机调度
C. 在进程处于临界区时不能进行处理机调度
D. 在系统调用完成并返回用户态时能进行处理机调度

P134 31. 系统中有三个不同的临界资源R1，R2和R3，被4个进程P1，P2，P3，P4共享。各进程对资源的需求为：P1申请R1和R2，P2申请R2和R3，P3申请R1和R3，P4申请R2。若系统出现死锁，则处于死锁状态的进程数至少是（）。

A. 1
B. 2
C. 3
D. 4

P134 32. 若系统S1采用死锁避免方法，S2采用死锁检测方法。下列叙述中，正确的是（）。

I. S1会限制用户申请资源的顺序，而S2不会
II. S1需要进程运行所需的资源总量信息，而S2不需要
III. S1不会给可能导致死锁的进程分配资源，而S2会

A. 仅I、II
B. 仅II、III
C. 仅I、III
D. I、II、III

综合应用题之进程同步大题

P97 6. 在一个仓库中可以存放A和B两种产品，要求：

  1. 每次只能存入一种产品。
  2. A产品数量-B产品数量 < M。
  3. B产品数量-A产品数量 < N。

其中M、N是正整数，试用P操作、V操作描述产品A与产品B的入库过程。

semaphore a = M - 1;        // A - B，即仓库中还可容纳多少个A产品
semaphore b = N - 1;        // B - A，即仓库中还可容纳多少个B产品
semaphore mutex = 1;        // 用于互斥访问仓库

A() {                       // A产品的入库过程
    while (1) {
        P(a);               // 仓库中还可容纳A产品的数量-1
        P(mutex);
        A产品入库;
        V(mutex);
        V(b);               // 仓库中还可容纳B产品的数量+1
    }
}

B() {                       // B产品的入库过程
    while (1) {
        P(b);               // 仓库中还可容纳B产品的数量-1
        P(mutex);
        B产品入库;
        V(mutex);
        V(a);               // 仓库中还可容纳A产品的数量+1
    }
}

P97 7. 面包师有很多面包，由n名销售人员销售。每名顾客进店后取一个号，并且等待叫号；当一名销售人员空闲时，就叫下一个号。试设计一个使销售人员和顾客同步的算法。

int i = 0, j = 0;           // i为下一名顾客要取走的号，j为下一个要叫的号
semaphore mutex_i = 1;      // 互斥访问i
semaphore mutex_j = 1;      // 互斥访问j

customer() {                // 顾客
    while (1) {
        走进面包店;
        P(mutex_i);         // 获取变量i的锁
        取走i号;
        i++;
        V(mutex_i);         // 释放i的锁
        等待叫号; 买面包;
    }
}

seller() {
    while (1) {
        P(mutex_j);         // 获取j的锁
        if (i >= j) {       // i >= j说明j号已经被顾客取走，此时有顾客在等待
            叫号j;
            j++;
            V(mutex_j);     // 释放j的锁
            把面包卖给顾客;
        } else {
            V(mutex_j);     // 没有顾客在等待，释放j的锁
            休息片刻;
        }
    }
}

P98 10. 某寺庙有小和尚、老和尚若干，有一水缸，由小和尚提水入缸供老和尚饮用。水缸可容10桶水，水取自同一井中。水井径窄，每次只能容一个桶取水。水桶总数为3个。每次入缸取水仅为一桶水，且不可同时进行。试给出有关从缸取水，入水的算法描述。

semaphore bucket = 3;       // 表示有多少个水桶可以用
semaphore empty = 10;       // 表示水缸中还能容纳几桶水
semaphore full = 0;         // 表示水缸中已经装有几桶水
semaphore mutex1 = 1;       // 用于互斥地访问水缸
semaphore mutex2 = 1;       // 用于互斥地访问水井

老和尚() {
    while (1) {
        P(full);
        P(bucket);
        P(mutex1);
        从水缸中打一桶水;
        V(mutex1);
        V(empty);
        V(bucket);          // 错误点1：应该在喝水之后再释放水桶
        喝水;
    }
}

小和尚() {
    while (1) {
        P(bucket);
        P(mutex2);
        从井中打一桶水;
        V(mutex2);
        P(empty);           // 错误点2：这句应该放到最前面，若放在这里会产生死锁：当水缸全部装满、水桶全在小和尚手里且装满水时就会产生死锁。为了避免死锁，应该在开头使用P(empty)判断水缸中是否还能装水，如果不能装水则需要等待
        P(mutex1);
        把水倒入水缸;
        V(mutex1);
        V(full);
        V(bucket);
    }
}

semaphore well = 1;     // 用于互斥地访问水井
semaphore vat = 1;      // 用于互斥地访问水缸
semaphore empty = 10;   // 用于表示水缸中剩余空间能容纳的水的桶数
semaphore full = 0;     // 表示水缸中水的桶数
semaphore pail = 3;     // 表示有多少个水桶可以用，初值为3

老和尚() {
    while (1) {
        P(full);
        P(pail);
        P(vat);
        从水缸中打一桶水;
        V(vat);
        V(empty);
        喝水;
        V(pail);
    }
}

小和尚() {
    while (1) {
        P(empty);
        P(pail);
        P(well);
        从井中打一桶水;
        V(well);
        P(vat);
        将水倒入水缸中;
        V(vat);
        V(full);
        V(pail);
    }
}

P99 16. 设P、Q、R共享一个缓冲区，P，Q构成一对生产者-消费者，R既为生产者又为消费者。使用P、V操作实现其同步。

semaphore mutex = 1;        // 用于互斥地访问缓冲区
semaphore empty = 1;        // 用于表示缓冲区剩余空间大小
semaphore full = 0;         // 用于表示缓冲区中已有的消息数量

P() {
    while (1) {
        生产一个消息;
        P(empty);
        P(mutex);
        把消息放入缓冲区;
        V(mutex);
        V(full);
    }
}

Q() {
    while (1) {
        P(full);
        P(mutex);
        从缓冲区取消息;
        V(mutex);
        V(empty);
        消费消息;
    }
}

R() {
    while (1) {
        生产一个消息;
        P(empty);
        P(mutex);
        把消息放入缓冲区;
        V(mutex);
        V(full);
        P(full);
        P(mutex);
        从缓冲区取消息;
        V(mutex);
        V(empty);
        消费消息;
    }
}

semaphore mutex = 1;        // 用于互斥地访问缓冲区
semaphore empty = 1;        // 用于表示缓冲区剩余空间大小
semaphore full = 0;         // 用于表示缓冲区中已有的消息数量

P() {
    while (1) {
        生产一个消息;
        P(empty);
        P(mutex);
        把消息放入缓冲区;
        V(mutex);
        V(full);
    }
}

Q() {
    while (1) {
        P(full);
        P(mutex);
        从缓冲区取消息;
        V(mutex);
        V(empty);
        消费消息;
    }
}

R() {
    while (1) {
        if (empty == 1) {
            生产一个消息;
            P(empty);
            P(mutex);
            把消息放入缓冲区;
            V(mutex);
            V(full);
        }
        
        if (full == 1) {
            P(full);
            P(mutex);
            从缓冲区取消息;
            V(mutex);
            V(empty);
            消费消息;
        }
    }
}
上一篇下一篇

猜你喜欢

热点阅读