《操作系统》大题总结

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

Semaphore mutex1 = 1 //互斥访问F1
Semaphore mutex2 = 1//互斥访问F2
Semaphore empty1 = 10//F1上有几个空位
Semaphore full1 = 0//F1上有几个A
Semaphore empty2 = 10//F2上有几个空位
Semaphore full2 = 0 //F2上有几个B

//A车间
F_A(){
    while(1){
        生产一个产品A
        P(empty1)
        P(mutex1)
        把A放到货架F1上
        V(mutex1)
        V(full1)
    }
}

//B车间
F_B(){
    while(1){
        生产一个产品B
        P(empty2)
        P(mutex2)
        把A放到货架F2上
        V(mutex2)
        V(full2)
    }
}

//装配车间的工作描述
F_C(){
    while(1){
        P(full1)
        P(mutex1)
        从F1取一个A
        V(mutex1)
        V(empty1)
        P(full2)
        P(mutex2)
        从F2区一个B
        V(mutex2)
        V(empty2)
        将AB组装成产品
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

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);
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

    int num = 0; //有几个顾客等待服务
    Semaphore Lock = 1;//互斥访问num
    Semaphore rest = 0;//同步信号量，用于实现若没顾客，服务人员休息等待，本质为服务人员排队队列
    Seamphore wait = 0;//同步信号量，用于实现，若服务人员都在忙，顾客休息等待，本质为一个让顾客排队的队列

    Sever(){
        while(1){
            P(Lock);
            if(num > 0){//有顾客
                V(Lock);
                V(wait);//唤醒一个顾客
                为顾客服务;
            }else{ //没顾客
                V(Lock);
                P(rest);//服务人员休息
            }
        }
    }

    Customer(){
        P(Lock);
        if(num > 等待人数上限（存在无规定人数上限可能）){
            V(Lock);
            离开这家店;
        }else{
            num ++;
            V(Lock);
            V(rest);//唤醒一个正在休息的服务人员
            P(wait);//等待被服务
            被服务;
        }
    }

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

Semaphore empty = 10;//空座位的数目
Semaphore mutex = 1;//互斥使用取号机
Semaphore full = 0;//无占用的座位
Semaphore service = 0;//等待叫号

cobegin
{
    porcess 顾客i
    {
        P(empty);//等空位
        P(mutex);//申请使用取号机
        从取号机获取一个号码;
        V(mutex);//取号完毕
        V(full);//通知营业员有新顾客
        P(service);//等待营业员叫号
        接受服务;
    }

    process 营业员
    {
        while(1){
            P(full);//没有顾客则休息
            V(empty);//离开座位
            V(service);//叫号
            为顾客服务;
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

Semaphore Lock = 1;//互斥信号量，定义大锁
int a = 9;
int b = 3; 
int c = 6;

process(){
    while(1)
    {
        P(Lock);
        if(所有资源都拿够){
            所有资源int值减少;//题目会告知，每种资源所需量
            取xxx资源//一口气拿走所有资源
            V(Lock);//拿完资源，解锁
            break;//跳出while循环
        }
        V(Lock);//资源不足，解锁，再次循环尝试获取
    }
    做进程该做的事（如哲学家进食）

    P(Lock);
    归还所有资源，所有资源int值增减
    V(Lock);
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

Semaphore bowl;//协调哲学家对碗的使用
Semaphore chopsticks[n];//协调哲学家对筷子的使用

for(int i = 0; i < n ;i++)
{
    chopsticks[i] = 1;//设置两名哲学家之间筷子的数量
}
bowl = min(n-1,m);//bowl 小于等于 n-1，确保不产生死锁

cobegin
{
    while(1){ //哲学家i的程序
        思考;
        P(bowl);//取碗
        P(chopsticks[i]);//取左边筷子
        P(chopsticks[(i+1)%n]);//取右边筷子
        就餐;
        V(chopsticks[i]);
        V(chopsticks[(i+1)%n]);
        V(bowl);
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

Semaphore Lock = 1;
int bowl = m;
int chopstick[n];
for(int i = 0;i < n ; i++)
{
    chopstick[i] = 1;
}
philopher()
{
    while(1){//一次性拿下所有资源
        P(Lock);
        if(bowl <= 0)
        {
            V(Lock);
            continue;
        }
        if(!(chopstick[i] == 1 && chopstick[(i+1)%n]==1))
        {
            V(Lock);
            continue;
        }
        bowl --;
        chopstick[i] = 0;
        chopstick[(i+1)%n] = 0;
        V(Lock);
    }
    进餐
    P(Lock);//归还所有拿的资源
    bowl ++;
    chopstick[i] = 1;
    chopstick[(i+1)%n] = 1;
    V(Lock);
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

Semaphore Lock = 1;//资源锁
int count = 0;//同类进程计数器
Semaphore mutex = 1;//对count 互斥访问
homie(){
    P(mutex);
    if(count ==0)
    {
        P(Lock);
    }
    count ++;
    V(mutex);
    使用资源;
    if(count == 1)
    {
        V(Lock);
    }
    count --;
    V(mutex);
}

1
2
3
4
5

solo(){
    P(Lock);//使用前上锁
    使用资源;
    V(Lock);//用完了解锁
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

Semaphore bridge = 1;
NtoS(){
    P(bridge);
    通过桥;
    V(bridge);
}
StoN(){
    P(bridge);
    通过桥；
    V(bridge);
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

int countSN = 0;//表示从S到N的汽车数量
int countNS = 0;//表示从N到S的汽车数量
Semaphore mutexSN = 1;//保护countSN
Semaphore mutexNS = 1;//保护countNS
Semaphore bridge = 1;//互斥地访问桥
StoN(){//南到北
    P(mutexSN);
    //第一个进程上锁
    if(countSN==0)
        P(bridge);
    count ++;
    V(mutexSN);
    过桥；
    P(mutexSN);
    //最后一个进程解锁
    countSN--;
    if(countSN==0)
        V(bridge);
    V(mutexSN);
}

NtoS(){//北到南
    P(mutexNS);
    if(countNS==0)
        P(bridge);
    countNS++;
    V(mutexNS);
    过桥;
    P(mutexNS);
    countNS--;
    if(countNS ==0)
        V(bridge);
    V(mutexNS);
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67

Semaphore room = 1;
Semaphore mutex1 = 1;
Semaphore mutex2 = 1;
Semaphore mutex3 = 1;
int count1 = 0;
int count2 = 0;
int count3 = 0;

P1(){
    P(mutex1);
    count1 ++;
    //第一个上锁
    if(count1 == 1)
    {
        P(room);
    }
    V(mutex1);
    看影片1;
    P(mutex1);
    count1 --;
    //最后一个解锁
    if(count1 == 0)
    {
        V(room);
    }
    V(mutex1);
}

P2(){
    P(mutex2);
    count2 ++;
    //第一个上锁
    if(count2 == 1)
    {
        P(room);
    }
    V(mutex2);
    看影片2;
    P(mutex2);
    count2 --;
    //最后一个解锁
    if(count2 == 0)
    {
        V(room);
    }
    V(mutex2);
}

P3(){
    P(mutex3);
    count3 ++;
    //第一个上锁
    if(count3 == 1)
    {
        P(room);
    }
    V(mutex3);
    看影片3;
    P(mutex3);
    count3 --;
    //最后一个解锁
    if(count3 == 0)
    {
        V(room);
    }
    V(mutex3);
}