Semaphores (counting and binary) in Operating Systems - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to declare a binary semaphore initialized to 1.

Operating Systems

binary_semaphore = Semaphore([1])

Drag options to blanks, or click blank then click option'

A2

B0

C1

D-1

Attempts:

3 left

💡 Hint

Common Mistakes

Initializing binary semaphore to 0 causes immediate blocking.

Using negative values is invalid for semaphore initialization.

A binary semaphore is initialized to 1 to indicate that the resource is available.

2fill in blank

medium

Complete the code to initialize a counting semaphore with 5 available resources.

Operating Systems

counting_semaphore = Semaphore([1])

Drag options to blanks, or click blank then click option'

A5

B0

C1

D-5

Attempts:

3 left

💡 Hint

Common Mistakes

Initializing counting semaphore to 0 blocks all threads initially.

Negative initialization values are invalid.

A counting semaphore initialized to 5 means 5 resources are available for concurrent access.

3fill in blank

hard

Fix the error in the code to correctly wait (P operation) on a semaphore.

Operating Systems

semaphore.[1]()

Drag options to blanks, or click blank then click option'

Asignal

Bwait

Crelease

Dpost

Attempts:

3 left

💡 Hint

Common Mistakes

Using signal() or post() instead of wait() causes incorrect semaphore behavior.

Confusing wait() with release() method.

The wait() method is used to decrement the semaphore and block if the resource is unavailable.

4fill in blank

hard

Fill both blanks to correctly signal (V operation) a semaphore and update the resource count.

Operating Systems

semaphore.[1]()
resource_count [2] 1

Drag options to blanks, or click blank then click option'

Asignal

B+=

C-=

Dwait

Attempts:

3 left

💡 Hint

Common Mistakes

Using wait() instead of signal() causes deadlock.

Decreasing resource count after signaling is incorrect.

The signal() method releases the semaphore, and the resource count increases by 1.

5fill in blank

hard

Fill all three blanks to create a dictionary comprehension that maps resource names to their availability status using a binary semaphore.

Operating Systems

availability = [1]: semaphore.[2]() == 1 for [3] in resources

Drag options to blanks, or click blank then click option'

A{resource

Bwait

Cresource

D[resource

Attempts:

3 left

💡 Hint

Common Mistakes

Using square brackets instead of curly braces creates a list, not a dictionary.

Using signal() instead of wait() changes semaphore state incorrectly.

This dictionary comprehension checks if each resource is available by waiting on its semaphore and maps the resource name to a boolean.

Practice

1. What is the main purpose of a semaphore in operating systems?

easy

A. To manage user passwords

B. To increase the speed of the CPU

C. To store data permanently

D. To control access to shared resources and prevent conflicts

Solution

1. Step 1: Understand the role of semaphores

   Semaphores are synchronization tools used to manage access to shared resources in concurrent systems.

2. Step 2: Identify the correct purpose

   The main goal is to avoid conflicts by controlling how many processes can access a resource at once.

3. Final Answer:

   To control access to shared resources and prevent conflicts -> Option D

4. Quick Check:

   Semaphore controls resource access = A [OK]

Hint: Semaphores manage resource access to avoid conflicts [OK]

Common Mistakes:

• Confusing semaphores with memory storage
• Thinking semaphores speed up CPU
• Mixing semaphores with security functions

2. Which of the following is the correct way to initialize a binary semaphore with an initial value of 1?

easy

A. semaphore = Semaphore(0)

B. semaphore = Semaphore(2)

C. semaphore = Semaphore(1)

D. semaphore = Semaphore(-1)

Solution

1. Step 1: Recall binary semaphore initialization

   A binary semaphore can only have values 0 or 1, where 1 means resource is available.

2. Step 2: Choose the correct initial value

   Initializing with 1 means the resource is free initially, so Semaphore(1) is correct.

3. Final Answer:

   semaphore = Semaphore(1) -> Option C

4. Quick Check:

   Binary semaphore init with 1 = D [OK]

Hint: Binary semaphore starts at 1 to allow one user [OK]

Common Mistakes:

• Using 0 which blocks access initially
• Using negative values which are invalid
• Using values greater than 1 for binary semaphore

3. Consider a counting semaphore initialized to 3. If three processes call wait() on it, what will be the semaphore's value afterwards?

medium

A. 0

B. -3

C. 3

D. 1

Solution

1. Step 1: Understand counting semaphore behavior

   Each wait() call decreases the semaphore value by 1 if the resource is available.

2. Step 2: Calculate the new value after three waits

   Starting at 3, after three wait() calls, value = 3 - 3 = 0.

3. Final Answer:

   0 -> Option A

4. Quick Check:

   3 - 3 waits = 0 [OK]

Hint: Subtract one per wait call from initial count [OK]

Common Mistakes:

• Thinking semaphore goes negative immediately
• Confusing wait() with signal() effects
• Assuming semaphore resets automatically

4. A programmer wrote this code snippet using a binary semaphore:

semaphore = Semaphore(1)
semaphore.wait()
semaphore.wait()
semaphore.signal()

What is the problem with this code?

medium

A. It releases the semaphore twice causing an error

B. It causes a deadlock because the second wait() blocks indefinitely

C. It initializes the semaphore incorrectly

D. It does not use signal() after the first wait()

Solution

1. Step 1: Analyze the semaphore initial value and wait calls

   The semaphore starts at 1, so the first wait() decreases it to 0 (resource taken).

2. Step 2: Understand the effect of the second wait()

   The second wait() tries to decrease from 0, so it blocks waiting for signal().

3. Final Answer:

   It causes a deadlock because the second wait() blocks indefinitely -> Option B

4. Quick Check:

   Second wait on zero blocks = deadlock A [OK]

Hint: Second wait on binary semaphore without signal blocks [OK]

Common Mistakes:

• Thinking signal() is called twice
• Assuming semaphore initializes incorrectly
• Ignoring blocking behavior of wait()

5. You have a counting semaphore initialized to 5 to control access to a printer shared by multiple users. If 7 users try to access the printer simultaneously, how does the semaphore manage access?

hard

A. Allows 5 users to access immediately; 2 users wait until others release

B. Allows all 7 users to access simultaneously

C. Blocks all users until the semaphore is reset

D. Allows only 1 user at a time regardless of initial value

Solution

1. Step 1: Understand counting semaphore limits

   A counting semaphore with initial value 5 allows up to 5 concurrent accesses.

2. Step 2: Analyze user access requests

   When 7 users request access, 5 proceed immediately; the remaining 2 must wait for signal() calls.

3. Final Answer:

   Allows 5 users to access immediately; 2 users wait until others release -> Option A

4. Quick Check:

   Counting semaphore limits concurrent users = B [OK]

Hint: Counting semaphore limits concurrent access to initial count [OK]

Common Mistakes:

• Assuming all users access simultaneously ignoring limits
• Confusing counting semaphore with binary semaphore
• Thinking semaphore blocks all users at once