This lecture discusses concurrency and synchronization in operating systems. It introduces principles of concurrency and challenges such as sharing global resources. Mutual exclusion techniques like semaphores and monitors are presented to help manage concurrent access. The document also discusses interleaving and overlapping of processes on uni-processors and multi-processors. A simple example of an echo program is used to illustrate potential issues with determinism and reproducibility when processes run concurrently.

1. Lecture 4
Concurrency: Mutual
Exclusion and
Synchronization

2. Roadmap
• Principals of Concurrency
• Mutual Exclusion: Hardware Support
• Semaphores
• Monitors
• Message Passing
• Readers/Writers Problem

3. Multiple Processes
• Central to the design of modern Operating
Systems is managing multiple processes
– Multiprogramming
– Multiprocessing
– Distributed Processing
• Big Issue is Concurrency
– Managing the interaction of all of these
processes

4. Concurrency
Concurrency arises in:
• Multiple applications
– Sharing time
• Structured applications
– Extension of modular design
• Operating system structure
– OS themselves implemented as a set of
processes or threads

5. Key Terms

6. Interleaving and
Overlapping Processes
• Earlier (Ch2) we saw that processes may
be interleaved on uniprocessors

7. Interleaving and
Overlapping Processes
• And not only interleaved but overlapped
on multi-processors

8. Difficulties of
Concurrency
• Sharing of global resources
• Optimally managing the allocation of
resources
• Difficult to locate programming errors as
results are not deterministic and
reproducible.

9. A Simple Example
void echo()
{
chin = getchar();
chout = chin;
putchar(chout);
}

10. A Simple Example:
On a Multiprocessor
Process P1 Process P2
. .
chin = getchar(); .
. chin = getchar();
chout = chin; chout = chin;
putchar(chout); .
. putchar(chout);
. .