Introduction

Scheduling threads and synchronizing their execution is a common requirement in concurrent programming. In C++11, the std::condition_variable was introduced to facilitate thread synchronization. However, creating such mechanisms can be complex and error-prone. In C++20, two new synchronization primitives, std::latch and std::barrier, were introduced to simplify thread synchronization in certain scenarios.

In this blog post, I would like to demonstrate how to use create new implementations using std::latch and std::barrier to replace an existing producer-consumer model example implementation using std::condition_variable.

C++ Condition Variable

In my previous blog post “C++ Condition Variable”, I demonstrated how to use std::condition_variable introduced in C++11 to synchronize threads using the following producer-consumer model example.

wait_notify.cpp
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
#include <chrono>
#include <condition_variable>
#include <iostream>
#include <mutex>
#include <string>
#include <thread>

std::mutex m;
std::condition_variable cv;
std::string data;
bool ready = false;
bool processed = false;

void worker_thread()
{
    std::cout << "Worker thread start" << std::endl;
    std::unique_lock<std::mutex> lk(m);
    cv.wait(lk, [] { return ready; });

    
    std::cout << "Worker thread is processing data" << std::endl;
    data += " after processing";

    
    processed = true;
    std::cout << "Worker thread signals data processing completed" << std::endl;

    
    
    lk.unlock();
    
    
    cv.notify_one();
}

void master_thread()
{
    std::cout << "Master thread start" << std::endl;
    data = "Example data";
    
    {
        std::lock_guard<std::mutex> lk(m);
        ready = true;
        std::cout << "Master thread signals data ready for processing"
                  << std::endl;
    }
    
    
    cv.notify_one();

    
    {
        std::unique_lock<std::mutex> lk(m);
        cv.wait(lk, [] { return processed; });
    }
    std::cout << "Back in master thread, data = " << data << std::endl;
}

int main()
{
    std::thread worker(worker_thread), master(master_thread);
    
    
    worker.join();
    master.join();
}
1
2
3
4
5
6
7
8
$ g++ wait_notify.cpp -o wait_notify -std=c++11
$ ./wait_notify
Worker thread start
Master thread start
Master thread signals data ready for processing
Worker thread is processing data
Worker thread signals data processing completed
Back in master thread, data = Example data after processing

C++ Latch and Barrier

The above example works fine, but it requires careful management of mutexes, condition variables, and spurious wakeups, which is somewhat tedious and confusing. The same producer-consumer model example can be implemented more straightforwardly using the new synchronization primitives std::latch or std::barrier introduced in C++20.

The key difference between std::latch and std::barrier is that a latch is a one-time-use synchronization primitive, while a barrier can be reused multiple times. A latch is typically used when you want to wait for a set of threads to complete their tasks before proceeding, whereas a barrier is used when you want to synchronize a set of threads at multiple points in their execution.

C++ Latch

Compared to the implementation using std::condition_variable, the implementation using std::latch is much simpler and easier to understand.

latch.cpp
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
#include <chrono>
#include <iostream>
#include <latch>
#include <string>
#include <thread>

std::string data;
std::latch worker_latch(1); 
std::latch master_latch(1); 

void worker_thread()
{
    std::cout << "Worker thread start" << std::endl;
    
    worker_latch.wait();

    
    std::cout << "Worker thread is processing data" << std::endl;
    data += " after processing";

    
    std::cout << "Worker thread signals data processing completed" << std::endl;
    master_latch.count_down(); 
}

void master_thread()
{
    std::cout << "Master thread start" << std::endl;
    data = "Example data";
    
    std::cout << "Master thread signals data ready for processing"
              << std::endl;
    worker_latch.count_down(); 

    
    master_latch.wait();
    std::cout << "Back in master thread, data = " << data << std::endl;
}

int main()
{
    std::thread worker(worker_thread), master(master_thread);
    
    
    worker.join();
    master.join();
}
1
2
3
4
5
6
7
8
$ g++ latch.cpp -o latch -std=c++20
$ ./latch
Worker thread start
Master thread start
Master thread signals data ready for processing
Worker thread is processing data
Worker thread signals data processing completed
Back in master thread, data = Example data after processing

C++ Barrier

Similarly, the same example could be implemented using std::barrier. Note that in this case, instead of using two latches, we can reuse a single barrier for synchronization between the master and worker threads.

barrier.cpp
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
#include <barrier>
#include <chrono>
#include <iostream>
#include <string>
#include <thread>

std::string data;
std::barrier sync_point(2); 

void worker_thread()
{
    std::cout << "Worker thread start" << std::endl;
    
    sync_point.arrive_and_wait();

    
    std::cout << "Worker thread is processing data" << std::endl;
    data += " after processing";

    
    std::cout << "Worker thread signals data processing completed" << std::endl;
    sync_point.arrive_and_wait(); 
}

void master_thread()
{
    std::cout << "Master thread start" << std::endl;
    data = "Example data";
    
    std::cout << "Master thread signals data ready for processing"
              << std::endl;
    sync_point.arrive_and_wait(); 

    
    sync_point.arrive_and_wait();
    std::cout << "Back in master thread, data = " << data << std::endl;
}

int main()
{
    std::thread worker(worker_thread), master(master_thread);
    
    
    worker.join();
    master.join();
}
1
2
3
4
5
6
7
8
$ g++ barrier.cpp -o barrier -std=c++20
$ ./barrier
Worker thread start
Master thread start
Master thread signals data ready for processing
Worker thread is processing data
Worker thread signals data processing completed
Back in master thread, data = Example data after processing

Conclusions

The std::latch and std::barrier synchronization primitives introduced in C++20 are important concepts for thread synchronization especially used in producer-consumer models. They provide a simpler and more intuitive way to manage thread synchronization compared to traditional methods using mutexes and condition variables.

References