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

FreeBSD Manual Pages

  
 
  

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

NAME
       std::try_lock - std::try_lock

Synopsis
	  Defined in header <mutex>
	  template< class Lockable1, class Lockable2, class... LockableN >
	  int  try_lock(  Lockable1&  lock1,  Lockable2&  lock2, LockableN&...
       lockn  (since C++11)
	  );

	  Tries	to lock	each of	the given Lockable objects lock1, lock2,  ...,
       lockn by	calling
	  try_lock in order beginning with the first.

	  If  a	 call  to  try_lock fails, no further call to try_lock is per-
       formed, unlock is
	  called for any locked	objects	and a 0-based index of the object that
       failed to lock
	  is returned.

	  If a call to try_lock	results	in an exception, unlock	is called  for
       any locked
	  objects before rethrowing.

Parameters
	  lock1, lock2,	... , lockn - the Lockable objects to lock

Return value
	  -1  on  success, or 0-based index value of the object	that failed to
       lock.

Example
	  The following	example	uses std::try_lock to periodically  tally  and
       reset counters
	  running in separate threads.

       // Run this code

	#include <mutex>
	#include <vector>
	#include <thread>
	#include <iostream>
	#include <functional>
	#include <chrono>

	int main()
	{
	    int	foo_count = 0;
	    std::mutex foo_count_mutex;
	    int	bar_count = 0;
	    std::mutex bar_count_mutex;
	    int	overall_count =	0;
	    bool done =	false;
	    std::mutex done_mutex;

	    auto  increment  =	[](int	&counter,  std::mutex  &m,  const char
       *desc) {
		for (int i = 0;	i < 10;	++i) {
		    std::unique_lock<std::mutex> lock(m);
		    ++counter;
		    std::cout << desc << ": " << counter << '\n';
		    lock.unlock();
		    std::this_thread::sleep_for(std::chrono::seconds(1));
		}
	    };

	    std::thread	increment_foo(increment, std::ref(foo_count),
		std::ref(foo_count_mutex), "foo");
	    std::thread	increment_bar(increment, std::ref(bar_count),
		std::ref(bar_count_mutex), "bar");

	    std::thread	update_overall([&]() {
		done_mutex.lock();
		while (!done) {
		    done_mutex.unlock();
		    int	result = std::try_lock(foo_count_mutex,	 bar_count_mu-
       tex);
		    if (result == -1) {
			overall_count += foo_count + bar_count;
			foo_count = 0;
			bar_count = 0;
			std::cout << "overall: " << overall_count << '\n';
			foo_count_mutex.unlock();
			bar_count_mutex.unlock();
		    }
		    std::this_thread::sleep_for(std::chrono::seconds(2));
		    done_mutex.lock();
		}
		done_mutex.unlock();
	    });

	    increment_foo.join();
	    increment_bar.join();
	    done_mutex.lock();
	    done = true;
	    done_mutex.unlock();
	    update_overall.join();

	    std::cout << "Done processing\n"
		      << "foo: " << foo_count << '\n'
		      << "bar: " << bar_count << '\n'
		      << "overall: " <<	overall_count << '\n';
	}

Possible output:
	bar: 1
	foo: 1
	foo: 2
	bar: 2
	foo: 3
	overall: 5
	bar: 1
	foo: 1
	bar: 2
	foo: 2
	bar: 3
	overall: 10
	bar: 1
	foo: 1
	bar: 2
	foo: 2
	overall: 14
	bar: 1
	foo: 1
	bar: 2
	overall: 17
	foo: 1
	bar: 1
	foo: 2
	overall: 20
	Done processing
	foo: 0
	bar: 0
	overall: 20

See also
	  lock	  locks	specified mutexes, blocks if any are unavailable
	  (C++11) (function template)

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

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

home | help