std::latch

 

C++

Language

Standard Library Headers

Freestanding and hosted implementations

Named requirements

Language support library

Concepts library (C++20)

Diagnostics library

Utilities library

Strings library

Containers library

Iterators library

Ranges library (C++20)

Algorithms library

Numerics library

Localizations library

Input/output library

Filesystem library (C++17)

Regular expressions library (C++11)

Atomic operations library (C++11)

Thread support library (C++11)

Technical Specifications

 

Thread support library

Threads
thread (C++11)
jthread (C++20)
stop_token (C++20)
stop_source (C++20)
stop_callback (C++20)
hardware_destructive_interference_sizehardware_constructive_interference_size (C++17)(C++17)
this_thread namespace
get_id (C++11) yield (C++11)	sleep_for (C++11) sleep_until (C++11)
Mutual exclusion
mutex (C++11) recursive_mutex (C++11) shared_mutex (C++17)	timed_mutex (C++11) recursive_timed_mutex (C++11) shared_timed_mutex (C++14)
Generic lock management
lock_guard (C++11) scoped_lock (C++17) unique_lock (C++11) shared_lock (C++14) defer_lock_ttry_to_lock_tadopt_lock_t (C++11)(C++11)(C++11)	lock (C++11) try_lock (C++11) defer_locktry_to_lockadopt_lock (C++11)(C++11)(C++11) once_flag (C++11) call_once (C++11)
Condition variables
condition_variable (C++11)
condition_variable_any (C++11)
notify_all_at_thread_exit (C++11)
cv_status (C++11)
Semaphores
counting_semaphorebinary_semaphore (C++20)(C++20)
Latches and barriers
latch (C++20)
barrier (C++20)
Futures
promise (C++11) future (C++11) shared_future (C++11) packaged_task (C++11) async (C++11)	launch (C++11) future_status (C++11) future_error (C++11) future_category (C++11) future_errc (C++11)

 

std::latch

Member functions

latch::latch

latch::~latch

latch::count_down

latch::try_wait

latch::wait

latch::arrive_and_wait

Constants

latch::max

 

Defined in header <latch>
class latch;		(since C++20)

The latch class is a downward counter of type ptrdiff_t which can be used to synchronize threads. The value of the counter is initialized on creation. Threads may block on the latch until the counter is decremented to zero. There is no possibility to increase or reset the counter, which makes the latch a single-use barrier.

Concurrent invocations of the member functions of latch, except for the destructor, do not introduce data races.

Unlike std::barrier, std::latch can be decremented by a participating thread more than once.

Member functions

(constructor)	constructs a latch (public member function)
(destructor)	destroys the latch (public member function)
operator= [deleted]	latch is not assignable (public member function)
count_down	decrements the counter in a non-blocking manner (public member function)
try_wait	tests if the internal counter equals zero (public member function)
wait	blocks until the counter reaches zero (public member function)
arrive_and_wait	decrements the counter and blocks until it reaches zero (public member function)
Constants
max [static]	the maximum value of counter supported by the implementation (public static member function)

Example

Run this code

#include <functional>
#include <iostream>
#include <latch>
#include <string>
#include <thread>
 
int main() {
  struct job {
    const std::string name;
    std::string product{"not worked"};
    std::thread action{};
  } jobs[] = {{"annika"}, {"buru"}, {"chuck"}};
 
  std::latch work_done{std::size(jobs)};
  std::latch start_clean_up{1};
 
  auto work = [&](job& my_job) {
    my_job.product = my_job.name + " worked";
    work_done.count_down();
    start_clean_up.wait();
    my_job.product = my_job.name + " cleaned";
  };
 
  std::cout << "Work starting... ";
  for (auto& job : jobs) {
    job.action = std::thread{work, std::ref(job)};
  }
  work_done.wait();
  std::cout << "done:\n";
  for (auto const& job : jobs) {
    std::cout << "  " << job.product << '\n';
  }
 
  std::cout << "Workers cleaning up... ";
  start_clean_up.count_down();
  for (auto& job : jobs) {
    job.action.join();
  }
  std::cout << "done:\n";
  for (auto const& job : jobs) {
    std::cout << "  " << job.product << '\n';
  }
}

Output:

Work starting... done:
  annika worked
  buru worked
  chuck worked
Workers cleaning up... done:
  annika cleaned
  buru cleaned
  chuck cleaned

See also

barrier (C++20)

reusable thread barrier (class template)