Search⌘ K
Home
Courses
Modern C++ Concurrency: Get the most out of any machine

Synchronization with Fences

Explore how to implement synchronization using fences in modern C++. Understand the role of acquire and release memory_order fences to prevent operation reordering and ensure correct synchronization between threads. This lesson guides you through converting atomic operations to relaxed semantics combined with fences, and explains the happens-before relationship critical for concurrent programming.

We'll cover the following...

It’s quite straightforward to port the program to use fences.

C++
// acquireReleaseFences.cpp
#include <atomic>
#include <thread>
#include <iostream>
#include <string>
using namespace std;
 
atomic<string*> ptr;
int data;
atomic<int> atoData;
 
void producer(){
    string* p  = new string("C++11");
    data = 2011;
    atoData.store(2014, memory_order_relaxed);
    atomic_thread_fence(memory_order_release);
    ptr.store(p, memory_order_relaxed);
}
 
void consumer(){
    string* p2;
    while (!(p2 = ptr.load(memory_order_relaxed)));
    atomic_thread_fence(memory_order_acquire);
    cout << "*p2: " << *p2 << endl;
    cout << "data: " << data << endl;
    cout << "atoData: " << atoData.load(memory_order_relaxed) << endl;
}
 
int main(){
    
    cout << endl;
    
    thread t1(producer);
    thread t2(consumer);
    
    t1.join();
    t2.join();
    
    delete ptr;
    
    cout << endl;
    
}

The first step was to add fences with the acquire and release semantic (lines 18 and 25). Next, I changed the atomic operations with acquire or release semantic to relaxed semantic (lines 17 and 24) - which was straightforward. Of course, I can ...