Introduction
In this article, we will learn how to implement parallel tasks, allowing multiple threads to synchronously complete tasks across multiple stages.
The application scenario mainly involves controlling N threads (which can be increased or decreased at any time) so that multithreading can maintain synchronization across M stages.
The thread work situation is as follows:
Next, we will learn about the Barrier in C# to facilitate parallel collaborative work.
Barrier Class
The Barrier class allows multiple tasks to collaborate in parallel based on a certain algorithm across multiple stages, enabling multiple threads (referred to as "participants") to process the algorithm simultaneously in phases.
It enables multiple threads (referred to as "participants") to process the algorithm in phases. (Note the use of the term "algorithm.")
Each participant will be blocked from continuing until all participants have reached the same phase.
The constructor for the Barrier class is as follows:
| Constructor | Description |
|--------------|-------------|
| Barrier(Int32) | Initializes a new instance of the Barrier class. |
| Barrier(Int32, Action) | Initializes a new instance of the Barrier class. |
One of the constructors is defined as follows:
public Barrier (int participantCount, Action<barrier> postPhaseAction);
participantCount: The number of threads involved, greater than 0 and less than 32767.
postPhaseAction: An Action (delegate) executed after each phase.
Properties and Methods
Before clarifying what the class does, let's take a look at its common properties and methods.
After gaining a general understanding of the common properties and methods of Barrier, we will begin writing example code.
Properties:
| Property | Description |
|----------|-------------|
| CurrentPhaseNumber | Gets the current phase number of the barrier. |
| ParticipantCount | Gets the total number of participants in the barrier. |
| ParticipantsRemaining | Gets the number of participants that have not yet signaled in the current phase. |
Methods:
| Method | Description |
|--------|-------------|
| AddParticipant() | Notifies the Barrier that there will be another participant. |
| AddParticipants(Int32) | Notifies the Barrier that there will be multiple other participants. |
| RemoveParticipant() | Notifies the Barrier that there will be one less participant. |
| RemoveParticipants(Int32) | Notifies the Barrier that there will be several fewer participants. |
| SignalAndWait() | Signals that the participant has reached the barrier and waits for all other participants to do the same. |
| SignalAndWait(CancellationToken) | Signals that the participant has reached the barrier and waits for all other participants to reach the barrier while observing a cancellation token. |
| SignalAndWait(Int32) | Signals that the participant has reached the barrier and waits for all other participants to do the same, using a 32-bit signed integer to measure timeout. |
| SignalAndWait(Int32, CancellationToken) | Signals that the participant has reached the barrier and waits for all other participants to do the same, using a 32-bit signed integer to measure timeout while observing a cancellation token. |
| SignalAndWait(TimeSpan) | Signals that the participant has reached the barrier and waits for all other participants to do the same, using a TimeSpan object to measure the time interval. |
| SignalAndWait(TimeSpan, CancellationToken) | Signals that the participant has reached the barrier and waits for all other participants to do the same, using a TimeSpan object to measure the time interval while observing a cancellation token. |
The term "barrier" is used to translate Barrier, and the earlier mentioned "stage" is referred to as a barrier in the document. The official documentation provides some examples and practical scenarios:
https://docs.microsoft.com/zh-cn/dotnet/standard/threading/barrier?view=netcore-3.1
This tutorial is relatively simple; you can look at it first and then refer to the official examples.
Example
Let’s suppose there is a competition with three stages and three groups participating.
The competition consists of three stages. Once a group completes a stage, they can rest in a waiting area until the other groups finish before moving on to the next stage of the competition.
The example is as follows:
new Barrier(int, Action) sets how many threads participate, and the Action delegate sets what actions to perform after each stage is completed.
.SignalAndWait() blocks the current thread from proceeding until all others have reached this point.
class Program
{
// Barrier(Int32, Action)
private static Barrier barrier = new Barrier(3, b =>
Console.WriteLine($"\nStage {b.CurrentPhaseNumber + 1} of the competition is over. Please rate!"));
static void Main(string[] args)
{
// Random simulates the time required for each group to complete a stage of the competition
Thread thread1 = new Thread(() => DoWork("First Group", new Random().Next(2, 10)));
Thread thread2 = new Thread(() => DoWork("Second Group", new Random().Next(2, 10)));
Thread thread3 = new Thread(() => DoWork("Third Group", new Random().Next(2, 10)));
// Start the competition for the three groups
thread1.Start();
thread2.Start();
thread3.Start();
Console.ReadKey();
}
static void DoWork(string name, int seconds)
{
// First stage
Console.WriteLine($"\n{name}: Starting the first stage of competition");
Thread.Sleep(TimeSpan.FromSeconds(seconds)); // Simulating the time taken for the group to complete the stage
Console.WriteLine($"\n {name}: Completed the first stage. Waiting for other groups.");
// Groups complete stage tasks and wait for others to finish
barrier.SignalAndWait();
// Second stage
Console.WriteLine($"\n {name}: Starting the second stage of competition");
Thread.Sleep(TimeSpan.FromSeconds(seconds));
Console.WriteLine($"\n {name}: Completed the second stage. Waiting for other groups\n");
barrier.SignalAndWait();
// Third stage
Console.WriteLine($"\n {name}: Starting the third stage of competition");
Thread.Sleep(TimeSpan.FromSeconds(seconds));
Console.WriteLine($"\n {name}: Completed the third stage. Waiting for other groups\n");
barrier.SignalAndWait();
}
}
In the above example, each thread uses the DoWork() method to perform the same tasks. It is certainly possible to set multiple threads for different tasks, but it is crucial that every thread executes the same number of .SignalAndWait(); methods.
Additionally, SignalAndWait() can be configured with a wait time, preventing deadlock or similar issues if certain threads don’t reach this step promptly.
So far, we have only utilized SignalAndWait(). Let’s further explore other methods of the Barrier class.
New Example
Barrier.AddParticipant(): Add a participant;
Barrier.RemoveParticipant(): Remove a participant;
Here we will continue using the previous example.
Since this is a race, waiting for other groups might slow down the competition.
The new rule: Groups do not have to wait for the last one. When only the last participant remains, others can immediately proceed to the next stage of the competition.
Of course, the last group still has the right to finish the competition.
Modify the code in the second section by adding barrier.RemoveParticipant(); at the beginning of the Main method.
static void Main(string[] args)
{
barrier.RemoveParticipant();
... ...
Try running it again.
Note
There are many overloads for SignalAndWait(), such as SignalAndWait(CancellationToken). This article will not elaborate on how to use this method. When we get to asynchronous (Task), we will revisit this topic after readers have learned related concepts, making the progression from easy to difficult more intuitive.
Barrier is suitable for tasks that are executed simultaneously using the same processes since the work contents are identical, facilitating collaboration. Workflow might make use of this.
However, Barrier is particularly well-suited for algorithmic domains, as referenced here: https://devblogs.microsoft.com/pfxteam/parallel-merge-sort-using-barrier/
Of course, after studying asynchronous and parallel programming, I will provide corresponding algorithm examples.
文章评论