CODEWITHSUNDEEP
semaphore
Roman Kazmin
Roman Kazmin

Reputation: 981

Using semaphore with counter

Such a question.I am trying to understand how to use a semaphore. For exercise I took classical problem of readers / writers with a cyclic memory buffer. I would like to discuss only the writers. If I initialize the semaphore with a count greater than 1, I see that my writers can write to the same memory location. Then what is the meaning of the semaphore with the counter if it does not guarantee synchronized access to a shared resource? It seems I should have for each memory cell the separate semaphore.

Upvotes: 0

Views: 1381

Answers (2)

Kenney
Kenney

Reputation: 9093

Semaphore

Semaphores are a way to share a resource among multiple threads. In the Readers-writers problem, it is a way to guarantee consistency of the data, by preventing updates while it is being read, and preventing reads while it is being written to. It allows only one writer, and multiple concurrent readers.

Talking about semaphores is only useful if there are both readers and writers; In the case of an exclusive lock, where there can only be one thread who 'owns' the lock (has access to the resource), they are usually called Mutex (short for mutual exclusion).

Implementation

I implemented semaphores the other way around (due to CPU specifics): positive indicates how many readers there are, and a negative number indicates that there is one writer.

Initially the semaphore is 0, indicating no writer, and no readers.

Read Lock

Any time a reader wants to read, the semaphore must be 0 or positive, to support concurrent reads. If this is so, it is incremented. Positive numbers then, indicate that there are readers.
A reader would do a LOCK_READ, which succeeds, unless the semaphore is negative, indicating it is in the process of being written to and thus inconsistent. If this happens, the thread doing the read lock is suspended until the semaphore becomes 0 (or higher).

Write Lock

Any time a writer wants to write, the semaphore must be 0, because if it is positive, the readers may get partially updated (corrupt) data, and if it is negative, it is already locked for writing by another thread. If the semaphore indicates that the resource is not being accessed (0), the semaphore is decremented.

Unlocking

The unlocking is the reverse of the locking, except that there is no need to suspend the thread to unlock a resource. A read lock is lifted by decrementing the semaphore, and a write lock is lifted by incrementing the semaphore.

Upvotes: 0

OznOg
OznOg

Reputation: 4722

Well your use case is a special situation when the semaphore is initialized to 1 and behaves like a mutex. Obviously putting 2 would be an error as it would not be a correct lock anymore.

Nevertheless, semaphores a used in many other situations, for example, say you want to make sure that you do not have more than 5 thread running at a time.

You would setup the semaphore at 5, and each time you spawn a thread you do a down on it, and each time a thread finishes, you would do a up.

Trying to spawn the 6th thread would cause you to be 'stuck' in the down() until a thread eventually finishes at performs a up() that will unblock you.

Upvotes: 1

Related Questions