C++ barrier::arrive_and_drop() Function

The std::barrier::arrive_and_drop() function in C++, is designed to synchronize with the multiple threads. When this function is invoked, it signals that it has reached a specific synchronization point simultaneously drop out of the further synchronization cycles.

This function is particularly useful when a thread needs to synchronize only once or a limited number of times to a task, allowing it to exit without affecting the ongoing barrier synchronization.

Syntax

Following is the syntax for std::barrier::arrive_and_drop() function.

void arrive_and_drop();

Parameters

It does not accepts any parameter.

Return value

This function does not returns anything.

Exception

It throws std::system_error with an error code allowed for mutex types on error.

Example 1

In the following example, we are going to consider the basic usage of the arrive_and_drop() function.

#include <iostream>
#include <barrier>
#include <thread>
std::barrier sync_point(2);
void a(int b) {
   std::cout << "Thread " << b << " Working.\n";
   sync_point.arrive_and_drop();
   std::cout << "Thread " << b << " Finished.\n";
}
int main() {
   std::thread x1(a, 1);
   std::thread x2(a, 2);
   x1.join();
   x2.join();
   return 0;
}

Output

Output of the above code is as follows −

Thread 1 Working.
Thread 1 Finished.
Thread 2 Working.
Thread 2 Finished.

Example 2

Consider the following example, we are going to dynamically drop the thread based on a condition.

#include <iostream>
#include <thread>
#include <barrier>
void a(std::barrier < > & b, int c) {
   std::cout << "Thread " << c << " Working\n";
   if (c % 2 == 0) {
      b.arrive_and_drop();
      std::cout << "Thread " << c << " Is Leaving.\n";
   } else {
      b.arrive_and_wait();
      std::cout << "Thread " << c << " Synchronized.\n";
   }
}
int main() {
   std::barrier b(3);
   std::thread x1(a, std::ref(b), 1);
   std::thread x2(a, std::ref(b), 2);
   std::thread x3(a, std::ref(b), 3);
   x1.join();
   x2.join();
   x3.join();
   return 0;
}

Output

Following is the output of the above code −

Thread 2 Working
Thread 2 Is Leaving.
Thread 1 Working
Thread 3 Working
Thread 3 Synchronized.
Thread 1 Synchronized.