Lecture 10: Synchronization 1

Question 1

Process/Thread Synchronization

Answer 1

• For processes, threads to communicate, require shared data access
• Shared data access in unpredictable order determined by scheduler can lead to data inconsistencies and undesirable process / thread behaviors. Synchronization prevents that.

Question 2

Processes

Answer 2

IPC, shared files, …

Question 3

Threads

Answer 3

Shared memory communication

Question 4

Race Condition

Answer 4

Outcome of thread execution depends on timing of threads

Question 5

Synchronization

Answer 5

Use of atomic (i.e.: uninterruptible) operations to ensure correct cooperation amongst threads

Question 6

Mutual Exclusion

Answer 6

• Ensuring that only one thread does a particular thing
  (e. g.: Go to the store and buy milk) at a time
• one thread’s execution excludes the other

Question 7

Critical Section

Answer 7

• Piece of code that only one thread can execute at any time
  (i. e.: Only 1 thread at a time gets into this code)

-Typically: Code that reads, writes shared variables, files,…

Question 8

Lock

Answer 8

-Construct that prevents someone from doing something

e. g.: 1. Lock before entering critical section
2. Unlock when leaving critical section
- wait if locked

Question 9

Starvation

Answer 9

-Occurs when 1 or more threads never gets access to critical section

Question 10

Critical Sections Problem

Answer 10

-Ensure that only one thread executes its critical section at a time (avoid race condition)

Question 11

Producer-Consumer Problem

Answer 11

Producer produces objects into shared buffer
• Consumer consumes objects from shared buffer
• Producer, consumer run as separate threads
• Must ensure:
1. Consumer doesn’t remove from empty buffer
2. Producer doesn’t insert into full buffer (bounded-buffer only)

Question 12

Critical Sections Problem Goals of Solution

Answer 12

1. Mutual exclusion
   no more than 1 process in its critical section at a time
2. Progress: No thread outside of its critical section should block other threads
3. Bounded waiting: Must be a bound on number of times other threads allowed to enter their critical sections after thread has made request to enter its critical section and before request granted
   • assume each thread executes at non-zero speed