# std::latch

From cppreference.com
< cpp‎ | thread

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

The `latch` class is a downward counter of type std::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 `std::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)

### Notes

Feature-test macro
`__cpp_lib_latch`

### 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)

Retrieved from "https://en.cppreference.com/mwiki/index.php?title=cpp/thread/latch&oldid=137636"