Semaphore question

[HellsChicken]

If I have multiple threads all waiting on the same semaphore (the semaphores being in shared memory), is there any rule as to which gets allowed to run first when that semaphore is queued?

My guess to this answer would be no; that the thread which gets to pass on the one queue signal would be whichever thread is "lucky" enough to get it's CPU time first after the semaphore is signaled/queued.

If this is the case, is there any way to specify that you'd like the order of precedence to be the order in which they arrived?

[BobS0327]

Well, from a Win32 perspective, calling ReleaseSemaphore with a release count of the total number threads would release all the threads at the same time. Thus, they would all run "first". I really don't know if this is a good idea. There are contention and race issues that may have to be dealt with.

[Salem]

Mostly I would say it's a FIFO arrangement, the first thread to wait on the semaphore will be the next one to run when the semaphore is released.

Other systems use priority as well (if your threads have a priority), then the thread at the head of the highest priority queue waiting on the semaphore will be released.

If you want more specifics, state your OS/Compiler/Thread library

[BobS0327]

An answer from a Win32 perspective:

On the lowest level, the scheduler places these threads in a FIFO (First In/First Out) queue. On the application level, the order in which the threads are released is not always FIFO. The reason for this is that a waiting thread may be scheduled to perform an APC (asynchronous procedure call) such as an I/O completion routine. When the thread returns from the APC, it will once again be placed at the tail end of the queue of threads waiting for the synchronization object. If you have a situation in which it is critical for threads to be released in the order in which they arrived, you must implement your own queue on the application level. This will incur overhead as well as programming complexity and should really be avoided if possible

references: Advanced Windows, Richter, Microsoft Press and Multithreading Applications in Win32, Berveridge & Weinger, Addison Wesley