• Solving a Problem
  • CountdownEvent Class
  • Constructors and Methods
  • Example

Solving a Problem

Suppose a program needs to send 5 requests to a web service, but due to network fluctuations, there is a certain probability that a request will fail. If it fails, a retry is needed.

The example code is as follows:

    class Program
    {
        private static int count = 0;
        static void Main(string[] args)
        {
            for (int i = 0; i 
                {
                    HttpRequest();
                }).Start();
                return;
            }
            // Complete one task, +1
            Interlocked.Add(ref count,1);
            Console.WriteLine($"Task completed, count={count}");
        }
    }

The code is quite poor, but we can use the CountdownEvent class to improve it.

CountdownEvent Class

Represents a synchronization primitive that is signaled when its count reaches zero.

In other words, it sets a counter that subtracts 1 each time a thread completes, and when the counter reaches 0, it indicates that all threads have completed their tasks.

Constructors and Methods

The constructor of the CountdownEvent class is as follows:

| Constructor | Description |
|--------------|--------|
| CountdownEvent(Int32) | Initializes a new instance of the CountdownEvent class with the specified count. |

Common methods of the CountdownEvent class are as follows:

| Method | Description |
|--------|--------|
| AddCount() | Increments the current count of the CountdownEvent by 1. |
| AddCount(Int32) | Increments the current count of the CountdownEvent by the specified value. |
| Reset() | Resets the CurrentCount to the value of InitialCount. |
| Reset(Int32) | Resets the InitialCount property to the specified value. |
| Signal() | Signals the CountdownEvent, decrementing the CurrentCount. |
| Signal(Int32) | Signals the CountdownEvent multiple times, decrementing the CurrentCount by the specified amount. |
| TryAddCount() | Attempts to increment the CurrentCount by 1. |
| TryAddCount(Int32) | Attempts to increment the CurrentCount by the specified value. |
| Wait() | Blocks the current thread until the CountdownEvent is set. |
| Wait(CancellationToken) | Blocks the current thread until the CountdownEvent is set, while observing the CancellationToken. |
| Wait(Int32) | Blocks the current thread until the CountdownEvent is set, using a 32-bit signed integer to measure the timeout. |
| Wait(Int32, CancellationToken) | Blocks the current thread until the CountdownEvent is set, using a 32-bit signed integer to measure the timeout, while observing the CancellationToken. |
| Wait(TimeSpan) | Blocks the current thread until the CountdownEvent is set, using TimeSpan to measure the timeout. |
| Wait(TimeSpan, CancellationToken) | Blocks the current thread until the CountdownEvent is set, using TimeSpan to measure the timeout, while observing the CancellationToken. |

With many APIs, there's no rush; we can learn about it slowly.

Example

Let's write scenario code for a situation where there are five tasks to complete, and we send 5 people to accomplish them.

.Wait(); is used in a thread where this thread will wait until all other tasks are completed before it can continue execution.

Signal(); is used within the worker threads to signal the CountdownEvent object, indicating that the thread has completed its task; then CountdownEvent.CurrentCount will decrement by 1.

When the counter is 0, the blocked thread will resume execution.

The code example is as follows:

    class Program
    {
        // There are 5 tasks at hand
        private static CountdownEvent countd = new CountdownEvent(5);
        static void Main(string[] args)
        {
            Console.WriteLine("Starting to assign tasks");
            // Simultaneously calling 5 people to do 5 tasks
            for (int i = 0; i 

The example is straightforward; each thread needs to call the Signal() method to decrement the counter by 1 upon completion of its task.

.Wait(); can wait for all tasks to finish.

It’s important to note that if Signal() is not called or the counter does not reach 0, then Wait() will wait indefinitely.

Of course, Wait() can also set a timeout.

Additionally, we see common methods such as AddCount(), Reset(), etc.

The waiting control mechanism of this class is relatively loose; after Wait(), when exactly it can execute is completely based on the diligence of other threads.

If a thread fails to execute a task, we can choose not to call Signal() or use AddCount() to increase the count and perform a retry.