Skip site navigation (1)Skip section navigation (2)

FreeBSD Manual Pages

  
 
  

home | help 
std::latch(3)		      C++ Standard Libary		 std::latch(3)

NAME
       std::latch - std::latch

Synopsis
	  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 cre-
       ation. 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  participat-
       ing thread more
	  than once.

Member functions
	  constructor	  constructs a latch
			  (public member function)
	  destructor	  destroys the latch
			  (public member function)
	  operator=	  latch	is not assignable
	  [deleted]	  (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		  the maximum value of counter supported by the	imple-
       mentation
	  [static]	  (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 reusable thread barrier
	  (C++20) (class template)

http://cppreference.com		  2022.07.31			 std::latch(3)

Want to link to this manual page? Use this URL:
<https://man.freebsd.org/cgi/man.cgi?query=std::latch&sektion=3&manpath=FreeBSD+Ports+15.0>

home | help