history:
08.08.27   修改部份翻譯不當的地方   網友 wangk ; free2000fly  修改

MSDN中關于信號量的解釋如下：
{注：在某些書籍中 Semaphore Objects 翻譯為“信標”，有些則翻譯為“信號量”，本文均稱為“信號量”}
信號量(Semaphore Objects)
A semaphore object is a synchronization object that maintains a count between zero and a specified maximum value. The count is decremented each time a thread completes a wait for the semaphore object and incremented each time a thread releases the semaphore.
信號量是維護0到指定最大值之間的計數器的同步對象.當線程完成一次信號量的等待時，計數器自減1，當線程釋放信號量對象時，計數器自增1
{信號量用于對資源進行計數，它包括了
1、帶符號的數值 保存最大的資源數
2、帶符號的數值 保存當前可用的資源數
}

When the count reaches zero, no more threads can successfully wait for the semaphore object state to become signaled.  The state of a semaphore is set to signaled when its count is greater than zero, and nonsignaled when its count is zero.
當計數器為0時，不會再有其它線程等待信號量為受信狀態.計數器的值大于0時信號量對象受信，等于0時便不會受信.

The semaphore object is useful in controlling a shared resource that can support a limited number of users.
信號量對象用于支持有限用戶的共享資源控制

It acts as a gate that limits the number of threads sharing the resource to a specified maximum number.
它可以作為限制線程共享資源最大值的一種方法

For example, an application might place a limit on the number of windows that it creates. 
It uses a semaphore with a maximum count equal to the window limit, decrementing the count whenever a window is created and incrementing it whenever a window is closed. The application specifies the semaphore object in call to one of the wait functions before each window is created. When the count is zero — indicating that the window limit has been reached — the wait function blocks execution of the window-creation code.

例如，一個應用程序限制它所創建的窗體.把信號量的最大值設置為窗體個數的最大值, 當窗體創建時，信號量的值減少，當窗體關閉時，信號量的值增加.應用程序在窗體創建時調用 Wait 系列API函數.當計數為0時，證明窗體個數已經達到極限, wait 系列函數會阻塞創建窗體的代碼

A thread uses the CreateSemaphore or CreateSemaphoreEx function to create a semaphore object. The creating thread specifies the initial count and the maximum value of the count for the object. The initial count must be neither less than zero nor greater than the maximum value.
The creating thread can also specify a name for the semaphore object. Threads in other processes can open a handle to an existing semaphore object by specifying its name in a call to the OpenSemaphore function.

線程可以使用 CreateSemaphore 或 CreateSemaphoreEx 創建信號量對象
創建信號量的線程需要指出信號量的初始值和最大值
初始值必須大于0且不大于所指定的最大值
創建的線程同樣可以為信號量指定一個名字
其它進程的線程可以通過這個名字，然后調用 OpenSemaphore() 來打開已經存在的信號量對象

For additional information about names for mutex, event, semaphore, and timer objects, see Interprocess Synchronization.
If more than one thread is waiting on a semaphore, a waiting thread is selected. Do not assume a first-in, first-out (FIFO) order. External events such as kernel-mode APCs can change the wait order.

如果多于一條線程在等待信號量對象，wait 返回的那條線程并不會遵循先進先出（FIFO）的順序，因為內核模式可能改變它的順序。

Each time one of the wait functions returns because the state of a semaphore was set to signaled, the count of the semaphore is decreased by one. The ReleaseSemaphore function increases a semaphore's count by a specified amount. The count can never be less than zero or greater than the maximum value.
每次信號量受信，wait 系列函數就會返回, 同時計數會減1，
ReleaseSemaphore() 函數用來增加信號量的計數值，這個值永遠大于等于0且小于等于指定的最大值

The initial count of a semaphore is typically set to the maximum value. The count is then decremented from that level as the protected resource is consumed. Alternatively, you can create a semaphore with an initial count of zero to block access to the protected resource while the application is
being initialized. After initialization, you can use ReleaseSemaphore to increment the count to the maximum value.

信號量的初始值通常被設置為最大值，當被保護的資源被消耗時，其計數值會被減少。或者，你可以在創建信號值時把初始值指定為 0, 應用程序初始化時，保護資源會阻塞, 初始化后，你可以調用 ReleaseSemaphore  來增加信號量的計數值

A thread that owns a mutex object can wait repeatedly for the same mutex object to become signaled without its execution becoming blocked. A thread that waits repeatedly for the same semaphore object, however, decrements the semaphore's count each time a wait operation is completed; the thread is blocked when the count gets to zero. Similarly, only the thread that owns a mutex can successfully call the ReleaseMutex function, though any thread can use ReleaseSemaphore to increase the count of a semaphore object.

一條線程可以反復地等待 mutex 對象，在它受信前，不會去執行阻塞的代碼塊
同樣，一條線程也可以反復地等待 信號量 對象，
然而，在 wait 操作完成后，信號量的計數會減1,
當為0時，線程會阻塞
同樣地，只有當前擁有該mutex 的線程可以調用 ReleaseMutex 函數
但可以在任何線程通過調用 ReleaseSemaphore 函數來增加 信號量的計數

A thread can decrement a semaphore's count more than once by repeatedly specifying the same semaphore object in calls to any of the wait functions. However, calling one of the multiple-object wait functions with an array that contains multiple handles of the same semaphore does not result in multiple decrements.

線程可以通過反復等待一個信號量對象來讓信號量的計數自減
但是，如果調用 multiple-object wait 系列函數，等待的數組里指定為多個相同的信號量，這時并不會導致信號量的計數值多次自減。

相關WIN-API函數:
CreateSemaphore()
OpenSemaphore()
ReleaseSemaphore()
WaitForSingleObject()
CloseHandle()

本文內容摘自MSDN，有些地方翻譯得不好
歡迎交流，指正
聯系QQ：    859934020(經常隱身)
聯系E-mail:  kredraw@21cn.com