In the kindergarden around the corner they use a SemaphoreSlim to control how many kids can play in the PE room. They painted on the floor, outside of the room, 5 pairs of footprints. As the kids arrive, they leave their shoes on a free pair of footprints and enter the room. Once they are … Read more
If you access the AvailableWaitHandle property, then Yes, you must call Dispose() to cleanup unmanaged resources. If you do not access AvailableWaitHandle, then No, calling Dispose() won’t do anything important. SemaphoreSlim will create a ManualResetEvent on demand if you access the AvailableWaitHandle. This may be useful, for example if you need to wait on multiple … Read more
Turns out there isn’t a way to reliably recover the semaphore. Sure, anyone can post_sem() to the named semaphore to get the count to increase past zero again, but how to tell when such a recovery is needed? The API provided is too limited and doesn’t indicate in any way when this has happened. Beware … Read more
The problem you are facing is the misunderstanding of sem_init() function. When you read the manual page you will see this: The pshared argument indicates whether this semaphore is to be shared between the threads of a process, or between processes. If you are done reading up to this point, you will think that the … Read more
Okay, I am now connecting without the semaphore timeout problem. If anyone reading ever encounters the same thing, I hope that this procedure works for you; but no promises; hey, it’s windows. In my case this was Windows 7 I got a little hint from This page on eHow; not sure if that might help … Read more
Let’s say I create a semaphore. If I fork a bunch of child processes, will they all still use that same semaphore? If you are using a SysV IPC semaphore (semctl), then yes. If you are using POSIX semaphores (sem_init), then yes, but only if you pass a true value for the pshared argument on … Read more
CountDownLatch is frequently used for the exact opposite of your example. Generally, you would have many threads blocking on await() that would all start simultaneously when the countown reached zero. final CountDownLatch countdown = new CountDownLatch(1); for (int i = 0; i < 10; ++ i) { Thread racecar = new Thread() { public void … Read more
Unfortunately everyone has missed the most important difference between the semaphore and the mutex; the concept of “ownership“. Semaphores have no notion of ownership, this means that any thread can release a semaphore (this can lead to many problems in itself but can help with “death detection”). Whereas a mutex does have the concept of … Read more
Here is how I remember when to use what – Semaphore: Use a semaphore when you (thread) want to sleep till some other thread tells you to wake up. Semaphore ‘down’ happens in one thread (producer) and semaphore ‘up’ (for same semaphore) happens in another thread (consumer) e.g.: In producer-consumer problem, producer wants to sleep … Read more
A lock allows only one thread to enter the part that’s locked and the lock is not shared with any other processes. A mutex is the same as a lock but it can be system wide (shared by multiple processes). A semaphore does the same as a mutex but allows x number of threads to … Read more