Semaphore for Chess Timer Functionality in Windows API

Other Questions API
1

I’m looking for a semaphore that operates similarly to a Chess timer, meaning it allows one thread to complete its execution, then signals another thread to proceed. For instance, when Thread A finishes its task, it would signal and go back to the start, prompting Thread B to run its code. Once Thread B finishes, it signals back to Thread A to repeat the process. Hence, this semaphore would need to function in both blocking and signaling capacities. While I understand I could use two events with WaitForSingleObject, I’m curious if there’s a semaphore designed for this purpose specifically. Additionally, could you provide insights on how resource-intensive Events and the WaitForSingleObject function are regarding memory consumption and CPU usage?

2

To achieve the functionality you are describing, where threads alternate execution similar to a chess timer, you indeed might find semaphores somewhat limited for this purpose. Semaphores are usually utilized to control access to a shared resource by multiple threads, but they are not inherently designed to facilitate the alternating execution of threads.

Instead, using two Event objects (as you mentioned) with WaitForSingleObject offers an effective and commonly used pattern to achieve this behavior. Here’s a basic outline of how it could be implemented:

// Initialize event objects in non-signaled state
HANDLE eventA = CreateEvent(NULL, FALSE, FALSE, NULL);
HANDLE eventB = CreateEvent(NULL, FALSE, FALSE, NULL);

// Thread A procedure
DWORD WINAPI ThreadA(LPVOID lpParam) {
    while (true) {
        // Wait for signal from Thread B
        WaitForSingleObject(eventA, INFINITE);

        // [Thread A executes its task here]

        // Signal Thread B to proceed
        SetEvent(eventB);
    }
    return 0;
}

// Thread B procedure
DWORD WINAPI ThreadB(LPVOID lpParam) {
    while (true) {
        // Wait for signal from Thread A
        WaitForSingleObject(eventB, INFINITE);

        // [Thread B executes its task here]

        // Signal Thread A to proceed
        SetEvent(eventA);
    }
    return 0;
}

Regarding the efficiency of WaitForSingleObject and Events, they are designed to be lightweight. The intrinsic nature of events makes them efficient for synchronization needs since they don’t consume CPU when waiting, thanks to being kernel-mode objects. However, you'll need to consider that the creation and management of these objects could have a slight overhead, but generally, this is minimal in most applications.

While semaphores might not directly meet your requirements, they can sometimes be used in conjunction with other constructs to achieve complex thread synchronization. But in this case, the pairing of two events provides a clean and efficient solution.