synchronizationcsci315s20.courses.bucknell.edu/files/2020/09/...synchronization csci 315 operating...
TRANSCRIPT
![Page 1: Synchronizationcsci315s20.courses.bucknell.edu/files/2020/09/...Synchronization CSCI 315 Operating Systems Design Department of Computer Science Notice: The slides for this lecture](https://reader033.vdocuments.mx/reader033/viewer/2022051811/601c1f140c0396709a0a34e7/html5/thumbnails/1.jpg)
SynchronizationCSCI 315 Operating Systems Design
Department of Computer Science
Notice: The slides for this lecture are based on those for Operating Systems Concepts, 10th ed., by Silberschatz, Galvin, and Gagne. Many of the illustrations contained in this presentation come from this source.
![Page 2: Synchronizationcsci315s20.courses.bucknell.edu/files/2020/09/...Synchronization CSCI 315 Operating Systems Design Department of Computer Science Notice: The slides for this lecture](https://reader033.vdocuments.mx/reader033/viewer/2022051811/601c1f140c0396709a0a34e7/html5/thumbnails/2.jpg)
0
A Tale of a Shared Variable
code dataint a = 0;
files
registers
stack
PC
registers
stack
PC
T1 T2
multithreaded process
![Page 3: Synchronizationcsci315s20.courses.bucknell.edu/files/2020/09/...Synchronization CSCI 315 Operating Systems Design Department of Computer Science Notice: The slides for this lecture](https://reader033.vdocuments.mx/reader033/viewer/2022051811/601c1f140c0396709a0a34e7/html5/thumbnails/3.jpg)
1
The Bounded-Buffer Problem
producer consumer
shared buffercapacity n items
![Page 4: Synchronizationcsci315s20.courses.bucknell.edu/files/2020/09/...Synchronization CSCI 315 Operating Systems Design Department of Computer Science Notice: The slides for this lecture](https://reader033.vdocuments.mx/reader033/viewer/2022051811/601c1f140c0396709a0a34e7/html5/thumbnails/4.jpg)
2
Race Condition
Races usually occurs because programmers assume that threads will take some particular trajectory through the execution space, forgetting the golden rule that threaded programs must work correctly for any feasible trajectory.
Computer SystemsA Programmer’s Perspective
Randal Bryant and David O’Hallaron
A race occurs when the correctness of a program depends on one thread reaching point x in its control flow before another thread reaches point y.
![Page 5: Synchronizationcsci315s20.courses.bucknell.edu/files/2020/09/...Synchronization CSCI 315 Operating Systems Design Department of Computer Science Notice: The slides for this lecture](https://reader033.vdocuments.mx/reader033/viewer/2022051811/601c1f140c0396709a0a34e7/html5/thumbnails/5.jpg)
3
The Synchronization Problem
• Concurrent access to shared data may result in data inconsistency.
• Maintaining data consistency requires mechanisms to ensure the “orderly” execution of cooperating processes.
![Page 6: Synchronizationcsci315s20.courses.bucknell.edu/files/2020/09/...Synchronization CSCI 315 Operating Systems Design Department of Computer Science Notice: The slides for this lecture](https://reader033.vdocuments.mx/reader033/viewer/2022051811/601c1f140c0396709a0a34e7/html5/thumbnails/6.jpg)
4
The Critical-Section Problem Solution
1. Mutual Exclusion - If process Pi is executing in its critical section, then no other processes can be executing in their critical sections.
2. Progress - If no process is executing in its critical section and there exist some processes that wish to enter their critical section, then the selection of the processes that will enter the critical section next cannot be postponed indefinitely.
3. Bounded Waiting - A bound must exist on the number of times that other processes are allowed to enter their critical sections after a process has made a request to enter its critical section and before that request is granted. (Assume that each process executes at a nonzero speed. No assumption concerning relative speed of the N processes.)
![Page 7: Synchronizationcsci315s20.courses.bucknell.edu/files/2020/09/...Synchronization CSCI 315 Operating Systems Design Department of Computer Science Notice: The slides for this lecture](https://reader033.vdocuments.mx/reader033/viewer/2022051811/601c1f140c0396709a0a34e7/html5/thumbnails/7.jpg)
Typical Process Pi
do {entry sectioncritical sectionexit section
remainder section} while (TRUE);
5
![Page 8: Synchronizationcsci315s20.courses.bucknell.edu/files/2020/09/...Synchronization CSCI 315 Operating Systems Design Department of Computer Science Notice: The slides for this lecture](https://reader033.vdocuments.mx/reader033/viewer/2022051811/601c1f140c0396709a0a34e7/html5/thumbnails/8.jpg)
Peterson’s Solution
int turn;
boolean flag[2];
6
do {flag[i] = TRUE;turn = j;
while (flag[j] && turn == j);critical sectionflag[i] = FALSE;remainder section
} while (TRUE);
![Page 9: Synchronizationcsci315s20.courses.bucknell.edu/files/2020/09/...Synchronization CSCI 315 Operating Systems Design Department of Computer Science Notice: The slides for this lecture](https://reader033.vdocuments.mx/reader033/viewer/2022051811/601c1f140c0396709a0a34e7/html5/thumbnails/9.jpg)
Using Locks
7
do {acquire lockcritical sectionrelease lockremainder section
} while (TRUE);
![Page 10: Synchronizationcsci315s20.courses.bucknell.edu/files/2020/09/...Synchronization CSCI 315 Operating Systems Design Department of Computer Science Notice: The slides for this lecture](https://reader033.vdocuments.mx/reader033/viewer/2022051811/601c1f140c0396709a0a34e7/html5/thumbnails/10.jpg)
8
Synchronization Hardware
• Many systems provide hardware support for critical section code.
• Uniprocessors (could disable interrupts):– Currently running code would execute without preemption.– Generally too inefficient on multiprocessor systems.– Operating systems using this not broadly scalable.
• Modern machines provide special atomic hardware instructions:– Test memory word and set value.– Swap the contents of two memory words.
![Page 11: Synchronizationcsci315s20.courses.bucknell.edu/files/2020/09/...Synchronization CSCI 315 Operating Systems Design Department of Computer Science Notice: The slides for this lecture](https://reader033.vdocuments.mx/reader033/viewer/2022051811/601c1f140c0396709a0a34e7/html5/thumbnails/11.jpg)
TestAndSet
9
boolean TestAndSet(boolean *target)
{ boolean ret_val = *target;
*target = TRUE;return ret_val;
}
![Page 12: Synchronizationcsci315s20.courses.bucknell.edu/files/2020/09/...Synchronization CSCI 315 Operating Systems Design Department of Computer Science Notice: The slides for this lecture](https://reader033.vdocuments.mx/reader033/viewer/2022051811/601c1f140c0396709a0a34e7/html5/thumbnails/12.jpg)
Lock with TestAndSet
10
boolean lock = FALSE;
do {while (TestAndSet(&lock));critical sectionlock = FALSE;remainder section
} while (TRUE);
![Page 13: Synchronizationcsci315s20.courses.bucknell.edu/files/2020/09/...Synchronization CSCI 315 Operating Systems Design Department of Computer Science Notice: The slides for this lecture](https://reader033.vdocuments.mx/reader033/viewer/2022051811/601c1f140c0396709a0a34e7/html5/thumbnails/13.jpg)
CompareAndSwap
11
int CompareAndSwap (int *value, int expected, int new_value){
int temp = *value;
if (*value == expected) *value = new_value; return temp;
}
![Page 14: Synchronizationcsci315s20.courses.bucknell.edu/files/2020/09/...Synchronization CSCI 315 Operating Systems Design Department of Computer Science Notice: The slides for this lecture](https://reader033.vdocuments.mx/reader033/viewer/2022051811/601c1f140c0396709a0a34e7/html5/thumbnails/14.jpg)
Lock with CompareAndSwap
12
int lock = 0;
do {while(CompareAndSwap(&lock,0,1) != 0);critical sectionlock = 0;remainder section
} while (TRUE);
![Page 15: Synchronizationcsci315s20.courses.bucknell.edu/files/2020/09/...Synchronization CSCI 315 Operating Systems Design Department of Computer Science Notice: The slides for this lecture](https://reader033.vdocuments.mx/reader033/viewer/2022051811/601c1f140c0396709a0a34e7/html5/thumbnails/15.jpg)
How are we meeting requirements?
Do the solutions above provide:
• Mutual exclusion?• Progress?• Bounded waiting?
13
![Page 16: Synchronizationcsci315s20.courses.bucknell.edu/files/2020/09/...Synchronization CSCI 315 Operating Systems Design Department of Computer Science Notice: The slides for this lecture](https://reader033.vdocuments.mx/reader033/viewer/2022051811/601c1f140c0396709a0a34e7/html5/thumbnails/16.jpg)
14
Semaphores• Counting semaphore – integer value can range over an unrestricted
domain.
• Binary semaphore – integer value can range only between 0 and 1; can be simpler to implement (also known as mutex locks).
• Provides mutual exclusion:
semaphore S(1); // initialized to 1
wait(S); // or acquire(S) or P(S) criticalSection(); signal(S); // or release(S) or V(S)
![Page 17: Synchronizationcsci315s20.courses.bucknell.edu/files/2020/09/...Synchronization CSCI 315 Operating Systems Design Department of Computer Science Notice: The slides for this lecture](https://reader033.vdocuments.mx/reader033/viewer/2022051811/601c1f140c0396709a0a34e7/html5/thumbnails/17.jpg)
15
Semaphore Implementation
typedef struct {int value;struct process *list;
} semaphore;
![Page 18: Synchronizationcsci315s20.courses.bucknell.edu/files/2020/09/...Synchronization CSCI 315 Operating Systems Design Department of Computer Science Notice: The slides for this lecture](https://reader033.vdocuments.mx/reader033/viewer/2022051811/601c1f140c0396709a0a34e7/html5/thumbnails/18.jpg)
16
Semaphore Implementationwait(semaphore *S) {
S->value--;if (S->value < 0) {
add process to S->listblock();
}}
signal(semaphore *S) { S->value++;if (S->value <= 0) {
remove a process P from S->listwakeup(P);
}}
![Page 19: Synchronizationcsci315s20.courses.bucknell.edu/files/2020/09/...Synchronization CSCI 315 Operating Systems Design Department of Computer Science Notice: The slides for this lecture](https://reader033.vdocuments.mx/reader033/viewer/2022051811/601c1f140c0396709a0a34e7/html5/thumbnails/19.jpg)
17
Semaphore Implementationsignal(semaphore *S) {
S->value++;if (S->value <= 0) {
remove a process P from S->listwakeup(P);
}}
wait(semaphore *S) { S->value--;if (S->value < 0) {
add process to S->listblock();
}}
![Page 20: Synchronizationcsci315s20.courses.bucknell.edu/files/2020/09/...Synchronization CSCI 315 Operating Systems Design Department of Computer Science Notice: The slides for this lecture](https://reader033.vdocuments.mx/reader033/viewer/2022051811/601c1f140c0396709a0a34e7/html5/thumbnails/20.jpg)
18
Semaphore Implementation
• Must guarantee that no two processes can execute signal() and wait() on the same semaphore “at the same time.”
• The implementation becomes the critical section problem:– Could now have busy waiting in critical section implementation
• But implementation code is short
• Little busy waiting if critical section rarely occupied
– Applications may spend lots of time in critical section
![Page 21: Synchronizationcsci315s20.courses.bucknell.edu/files/2020/09/...Synchronization CSCI 315 Operating Systems Design Department of Computer Science Notice: The slides for this lecture](https://reader033.vdocuments.mx/reader033/viewer/2022051811/601c1f140c0396709a0a34e7/html5/thumbnails/21.jpg)
19
The Bounded-Buffer Problem
int n;
mutex access;
semaphore empty;
semaphore full;
init(&access,1);
init(&empty,n);
init(&full,0);
producer consumer
shared buffercapacity n items
access
![Page 22: Synchronizationcsci315s20.courses.bucknell.edu/files/2020/09/...Synchronization CSCI 315 Operating Systems Design Department of Computer Science Notice: The slides for this lecture](https://reader033.vdocuments.mx/reader033/viewer/2022051811/601c1f140c0396709a0a34e7/html5/thumbnails/22.jpg)
CSCI 315 Operating Systems Design 20
The Bounded-Buffer Problem
producer consumer
Producer
do {// produce item and save
wait(&empty); wait(&access); // add item and save signal(&access); signal(&full);
} while (true);
![Page 23: Synchronizationcsci315s20.courses.bucknell.edu/files/2020/09/...Synchronization CSCI 315 Operating Systems Design Department of Computer Science Notice: The slides for this lecture](https://reader033.vdocuments.mx/reader033/viewer/2022051811/601c1f140c0396709a0a34e7/html5/thumbnails/23.jpg)
do {// produce item and save
wait(&empty); wait(&access); // add item and save signal(&access); signal(&full);
} while (true);
CSCI 315 Operating Systems Design 21
The Bounded-Buffer Problem
producer consumer
critical section
![Page 24: Synchronizationcsci315s20.courses.bucknell.edu/files/2020/09/...Synchronization CSCI 315 Operating Systems Design Department of Computer Science Notice: The slides for this lecture](https://reader033.vdocuments.mx/reader033/viewer/2022051811/601c1f140c0396709a0a34e7/html5/thumbnails/24.jpg)
22
The Bounded-Buffer Problem
producer consumer
Consumer
do { wait(&full);wait(&access);
// remove item and savesignal(&access);
signal(&empty);// consume save item
} while (true);
![Page 25: Synchronizationcsci315s20.courses.bucknell.edu/files/2020/09/...Synchronization CSCI 315 Operating Systems Design Department of Computer Science Notice: The slides for this lecture](https://reader033.vdocuments.mx/reader033/viewer/2022051811/601c1f140c0396709a0a34e7/html5/thumbnails/25.jpg)
23
The Bounded-Buffer Problem
do { wait(&full);wait(&access);
// remove item and savesignal(&access);
signal(&empty);// consume save item
} while (true);
producer consumer
critical section
![Page 26: Synchronizationcsci315s20.courses.bucknell.edu/files/2020/09/...Synchronization CSCI 315 Operating Systems Design Department of Computer Science Notice: The slides for this lecture](https://reader033.vdocuments.mx/reader033/viewer/2022051811/601c1f140c0396709a0a34e7/html5/thumbnails/26.jpg)
24
Deadlock and Starvation• Deadlock – two or more processes are waiting indefinitely for an event
that can be caused by only one of the waiting processes.
• Let S and Q be two semaphores initialized to 1 P0 P1
acquire(S); acquire(Q); acquire(Q); acquire(S);
. .
. .
. . release(S); release(Q); release(Q); release(S);
• Starvation – indefinite blocking. A process may never be removed from the semaphore queue in which it is suspended.
![Page 27: Synchronizationcsci315s20.courses.bucknell.edu/files/2020/09/...Synchronization CSCI 315 Operating Systems Design Department of Computer Science Notice: The slides for this lecture](https://reader033.vdocuments.mx/reader033/viewer/2022051811/601c1f140c0396709a0a34e7/html5/thumbnails/27.jpg)
25
The Dining-Philosophers Problem
![Page 28: Synchronizationcsci315s20.courses.bucknell.edu/files/2020/09/...Synchronization CSCI 315 Operating Systems Design Department of Computer Science Notice: The slides for this lecture](https://reader033.vdocuments.mx/reader033/viewer/2022051811/601c1f140c0396709a0a34e7/html5/thumbnails/28.jpg)
26
The Dining-Philosophers Problem
thinking
hungry
State diagram for a philosopher
eating
![Page 29: Synchronizationcsci315s20.courses.bucknell.edu/files/2020/09/...Synchronization CSCI 315 Operating Systems Design Department of Computer Science Notice: The slides for this lecture](https://reader033.vdocuments.mx/reader033/viewer/2022051811/601c1f140c0396709a0a34e7/html5/thumbnails/29.jpg)
27
The Dining-Philosophers Problem
![Page 30: Synchronizationcsci315s20.courses.bucknell.edu/files/2020/09/...Synchronization CSCI 315 Operating Systems Design Department of Computer Science Notice: The slides for this lecture](https://reader033.vdocuments.mx/reader033/viewer/2022051811/601c1f140c0396709a0a34e7/html5/thumbnails/30.jpg)
28
The Dining-Philosophers Problem
![Page 31: Synchronizationcsci315s20.courses.bucknell.edu/files/2020/09/...Synchronization CSCI 315 Operating Systems Design Department of Computer Science Notice: The slides for this lecture](https://reader033.vdocuments.mx/reader033/viewer/2022051811/601c1f140c0396709a0a34e7/html5/thumbnails/31.jpg)
29
The Dining-Philosophers Problem
![Page 32: Synchronizationcsci315s20.courses.bucknell.edu/files/2020/09/...Synchronization CSCI 315 Operating Systems Design Department of Computer Science Notice: The slides for this lecture](https://reader033.vdocuments.mx/reader033/viewer/2022051811/601c1f140c0396709a0a34e7/html5/thumbnails/32.jpg)
30
The Dining-Philosophers Problem
![Page 33: Synchronizationcsci315s20.courses.bucknell.edu/files/2020/09/...Synchronization CSCI 315 Operating Systems Design Department of Computer Science Notice: The slides for this lecture](https://reader033.vdocuments.mx/reader033/viewer/2022051811/601c1f140c0396709a0a34e7/html5/thumbnails/33.jpg)
31
The Dining-Philosophers Problem
![Page 34: Synchronizationcsci315s20.courses.bucknell.edu/files/2020/09/...Synchronization CSCI 315 Operating Systems Design Department of Computer Science Notice: The slides for this lecture](https://reader033.vdocuments.mx/reader033/viewer/2022051811/601c1f140c0396709a0a34e7/html5/thumbnails/34.jpg)
32
The Dining-Philosophers Problem
![Page 35: Synchronizationcsci315s20.courses.bucknell.edu/files/2020/09/...Synchronization CSCI 315 Operating Systems Design Department of Computer Science Notice: The slides for this lecture](https://reader033.vdocuments.mx/reader033/viewer/2022051811/601c1f140c0396709a0a34e7/html5/thumbnails/35.jpg)
Limit to Concurrency
What is the maximum number of philosophers that can be eating at any point in time?
33
![Page 36: Synchronizationcsci315s20.courses.bucknell.edu/files/2020/09/...Synchronization CSCI 315 Operating Systems Design Department of Computer Science Notice: The slides for this lecture](https://reader033.vdocuments.mx/reader033/viewer/2022051811/601c1f140c0396709a0a34e7/html5/thumbnails/36.jpg)
Philosopher’s Behavior
• Grab chopstick on left• Grab chopstick on right• Eat• Put down chopstick on right• Put down chopstick on left
34
How well does this work?
![Page 37: Synchronizationcsci315s20.courses.bucknell.edu/files/2020/09/...Synchronization CSCI 315 Operating Systems Design Department of Computer Science Notice: The slides for this lecture](https://reader033.vdocuments.mx/reader033/viewer/2022051811/601c1f140c0396709a0a34e7/html5/thumbnails/37.jpg)
35
The Dining-Philosophers Problem
![Page 38: Synchronizationcsci315s20.courses.bucknell.edu/files/2020/09/...Synchronization CSCI 315 Operating Systems Design Department of Computer Science Notice: The slides for this lecture](https://reader033.vdocuments.mx/reader033/viewer/2022051811/601c1f140c0396709a0a34e7/html5/thumbnails/38.jpg)
36
The Dining-Philosophers Problem
Question: How many philosophers can eat at once? How can we generalize this answer for n philosophers and n chopsticks?
Question: What happens if the programmer initializes the semaphores incorrectly? (Say, two semaphores start out a zero instead of one.)
Question: How can we formulate a solution to the problem so that there is no deadlock or starvation?
![Page 39: Synchronizationcsci315s20.courses.bucknell.edu/files/2020/09/...Synchronization CSCI 315 Operating Systems Design Department of Computer Science Notice: The slides for this lecture](https://reader033.vdocuments.mx/reader033/viewer/2022051811/601c1f140c0396709a0a34e7/html5/thumbnails/39.jpg)
37
Synonyms
wait signal
P V
acquire release
down up
… …
![Page 40: Synchronizationcsci315s20.courses.bucknell.edu/files/2020/09/...Synchronization CSCI 315 Operating Systems Design Department of Computer Science Notice: The slides for this lecture](https://reader033.vdocuments.mx/reader033/viewer/2022051811/601c1f140c0396709a0a34e7/html5/thumbnails/40.jpg)
38
The Sleeping Barber Problem
![Page 41: Synchronizationcsci315s20.courses.bucknell.edu/files/2020/09/...Synchronization CSCI 315 Operating Systems Design Department of Computer Science Notice: The slides for this lecture](https://reader033.vdocuments.mx/reader033/viewer/2022051811/601c1f140c0396709a0a34e7/html5/thumbnails/41.jpg)
39
The Sleeping Barber Problem
![Page 42: Synchronizationcsci315s20.courses.bucknell.edu/files/2020/09/...Synchronization CSCI 315 Operating Systems Design Department of Computer Science Notice: The slides for this lecture](https://reader033.vdocuments.mx/reader033/viewer/2022051811/601c1f140c0396709a0a34e7/html5/thumbnails/42.jpg)
40
The Sleeping Barber Problem
![Page 43: Synchronizationcsci315s20.courses.bucknell.edu/files/2020/09/...Synchronization CSCI 315 Operating Systems Design Department of Computer Science Notice: The slides for this lecture](https://reader033.vdocuments.mx/reader033/viewer/2022051811/601c1f140c0396709a0a34e7/html5/thumbnails/43.jpg)
41
The Sleeping Barber Problem
![Page 44: Synchronizationcsci315s20.courses.bucknell.edu/files/2020/09/...Synchronization CSCI 315 Operating Systems Design Department of Computer Science Notice: The slides for this lecture](https://reader033.vdocuments.mx/reader033/viewer/2022051811/601c1f140c0396709a0a34e7/html5/thumbnails/44.jpg)
42
The Sleeping Barber Problem
![Page 45: Synchronizationcsci315s20.courses.bucknell.edu/files/2020/09/...Synchronization CSCI 315 Operating Systems Design Department of Computer Science Notice: The slides for this lecture](https://reader033.vdocuments.mx/reader033/viewer/2022051811/601c1f140c0396709a0a34e7/html5/thumbnails/45.jpg)
43
The Sleeping Barber Problem
![Page 46: Synchronizationcsci315s20.courses.bucknell.edu/files/2020/09/...Synchronization CSCI 315 Operating Systems Design Department of Computer Science Notice: The slides for this lecture](https://reader033.vdocuments.mx/reader033/viewer/2022051811/601c1f140c0396709a0a34e7/html5/thumbnails/46.jpg)
44
The Sleeping Barber Problem
![Page 47: Synchronizationcsci315s20.courses.bucknell.edu/files/2020/09/...Synchronization CSCI 315 Operating Systems Design Department of Computer Science Notice: The slides for this lecture](https://reader033.vdocuments.mx/reader033/viewer/2022051811/601c1f140c0396709a0a34e7/html5/thumbnails/47.jpg)
45
The Sleeping Barber Problem
![Page 48: Synchronizationcsci315s20.courses.bucknell.edu/files/2020/09/...Synchronization CSCI 315 Operating Systems Design Department of Computer Science Notice: The slides for this lecture](https://reader033.vdocuments.mx/reader033/viewer/2022051811/601c1f140c0396709a0a34e7/html5/thumbnails/48.jpg)
46
The Sleeping Barber Problem
![Page 49: Synchronizationcsci315s20.courses.bucknell.edu/files/2020/09/...Synchronization CSCI 315 Operating Systems Design Department of Computer Science Notice: The slides for this lecture](https://reader033.vdocuments.mx/reader033/viewer/2022051811/601c1f140c0396709a0a34e7/html5/thumbnails/49.jpg)
47
The Sleeping Barber Problem
What entities are we modeling?
What behaviors are we modeling? (How do we synchronize behaviors?)
What are the shared structures?
![Page 50: Synchronizationcsci315s20.courses.bucknell.edu/files/2020/09/...Synchronization CSCI 315 Operating Systems Design Department of Computer Science Notice: The slides for this lecture](https://reader033.vdocuments.mx/reader033/viewer/2022051811/601c1f140c0396709a0a34e7/html5/thumbnails/50.jpg)
48
The Sleeping Barber Problem
What entities are we modeling?
• Customers• Barber• Barber chair• Waiting area
![Page 51: Synchronizationcsci315s20.courses.bucknell.edu/files/2020/09/...Synchronization CSCI 315 Operating Systems Design Department of Computer Science Notice: The slides for this lecture](https://reader033.vdocuments.mx/reader033/viewer/2022051811/601c1f140c0396709a0a34e7/html5/thumbnails/51.jpg)
49
The Sleeping Barber Problem
What entities are we modeling?
Customer process
Barber process
Barber Chair data
Waiting Area data
Entity Representation
![Page 52: Synchronizationcsci315s20.courses.bucknell.edu/files/2020/09/...Synchronization CSCI 315 Operating Systems Design Department of Computer Science Notice: The slides for this lecture](https://reader033.vdocuments.mx/reader033/viewer/2022051811/601c1f140c0396709a0a34e7/html5/thumbnails/52.jpg)
50
The Sleeping Barber Problem
What behaviors are we modeling? (How do we synchronize behaviors?)
sleepingcutting
hair
customer arrives
no customer
waiting customers
![Page 53: Synchronizationcsci315s20.courses.bucknell.edu/files/2020/09/...Synchronization CSCI 315 Operating Systems Design Department of Computer Science Notice: The slides for this lecture](https://reader033.vdocuments.mx/reader033/viewer/2022051811/601c1f140c0396709a0a34e7/html5/thumbnails/53.jpg)
51
Monitor• Semaphores are low-level synchronization resources.
• A programmer’s honest mistake can compromise the entire system (well, that is almost always true). We should want a solution that reduces risk.
• The solution can take the shape of high-level language constructs, as the monitor type:
A procedure can access only local variables defined within the monitor.
There cannot be concurrent access to procedures within the monitor (only one process/thread can be active in the monitor at any given time).
Condition variables: queues are associated with variables. Primitives for synchronization are wait and signal.
monitor mName { // shared variables declaration procedure P1 (…) { … } procedure Pn (…) { … } init code (…) { …. }}
![Page 54: Synchronizationcsci315s20.courses.bucknell.edu/files/2020/09/...Synchronization CSCI 315 Operating Systems Design Department of Computer Science Notice: The slides for this lecture](https://reader033.vdocuments.mx/reader033/viewer/2022051811/601c1f140c0396709a0a34e7/html5/thumbnails/54.jpg)
52
Monitor