What's the proper way to wait on a Semaphore?
.net, c#, multithreading, semaphore, waithandle
Solution
`WaitHandle.WaitAll(new WaitHandle[] { s });` waits just like `s.WaitOne();`. It enters at the first opportunity. You seem to expect this call to wait for all other semaphore operations but there is no way the operating system can tell the difference. This command might well be the first that is granted access to the semaphore.
I think what you need is the `Barrier` class. It is made for fork-join-style parallelism.
Problem
I thought that the following code would let all the 10 threads run, two at a time, and then print "done" after `Release()` is called 10 times. But that's not what happened: ``` int count = 0; Semaphore s = new Semaphore(2, 2); for (int x = 0; x < 10; x++) { Thread t = new Thread(new ThreadStart(delegate() { s.WaitOne(); Thread.Sleep(1000); Interlocked.Increment(ref count); s.Release(); })); t.Start(x); } WaitHandle.WaitAll(new WaitHandle[] { s }); Console.WriteLine("done: {0}", count); ``` output: ``` done: 6 ``` If the only way to implement the functionality I'm looking for is to pass an `EventWaitHandle` to each thread and then do a `WaitAll()` on an array of those `EventWaitHandles`, then what's the meaning of doing a `WaitAll()` on an array of only a semaphore? In other words, when does the waiting thread unblock?