Class interprocess_condition

boost::interprocess::interprocess_condition

Synopsis

// In header: <boost/interprocess/sync/interprocess_condition.hpp>


class interprocess_condition {
public:
  // construct/copy/destruct
  interprocess_condition();
  ~interprocess_condition();

  // public member functions
  void notify_one();
  void notify_all();
  template<typename L> void wait(L &);
  template<typename L, typename Pr> void wait(L &, Pr);
  template<typename L, typename TimePoint> 
    bool timed_wait(L &, const TimePoint &);
  template<typename L, typename TimePoint, typename Pr> 
    bool timed_wait(L &, const TimePoint &, Pr);
  template<typename L, typename TimePoint> 
    cv_status wait_until(L &, const TimePoint &);
  template<typename L, typename TimePoint, typename Pr> 
    bool wait_until(L &, const TimePoint &, Pr);
  template<typename L, typename Duration> 
    cv_status wait_for(L &, const Duration &);
  template<typename L, typename Duration, typename Pr> 
    bool wait_for(L &, const Duration &, Pr);
};

Description

This class is a condition variable that can be placed in shared memory or memory mapped files. Destroys the object of type std::condition_variable_any

Unlike std::condition_variable in C++11, it is NOT safe to invoke the destructor if all threads have been only notified. It is required that they have exited their respective wait functions.

`interprocess_condition` public construct/copy/destruct

```
interprocess_condition();
```
Constructs a interprocess_condition. On error throws interprocess_exception.
```
~interprocess_condition();
```
Destroys *this liberating system resources.

`interprocess_condition` public member functions

```
void notify_one();
```
If there is a thread waiting on *this, change that thread's state to ready. Otherwise there is no effect.
```
void notify_all();
```
Change the state of all threads waiting on *this to ready. If there are no waiting threads, notify_all() has no effect.
```
template<typename L> void wait(L & lock);
```
Releases the lock on the interprocess_mutex object associated with lock, blocks the current thread of execution until readied by a call to this->notify_one() or this->notify_all(), and then reacquires the lock.

template<typename L, typename Pr> void wait(L & lock, Pr pred);

The same as: while (!pred()) wait(lock)

```
template<typename L, typename TimePoint> 
  bool timed_wait(L & lock, const TimePoint & abs_time);
```
Releases the lock on the interprocess_mutex object associated with lock, blocks the current thread of execution until readied by a call to this->notify_one() or this->notify_all(), or until time abs_time is reached, and then reacquires the lock. Returns: false if time abs_time is reached, otherwise true.

template<typename L, typename TimePoint, typename Pr> 
  bool timed_wait(L & lock, const TimePoint & abs_time, Pr pred);

The same as: while (!pred()) { if (!timed_wait(lock, abs_time)) return pred(); } return true;

template<typename L, typename TimePoint> 
  cv_status wait_until(L & lock, const TimePoint & abs_time);

Same as timed_wait, but this function is modeled after the standard library interface.

template<typename L, typename TimePoint, typename Pr> 
  bool wait_until(L & lock, const TimePoint & abs_time, Pr pred);

Same as timed_wait, but this function is modeled after the standard library interface.

```
template<typename L, typename Duration> 
  cv_status wait_for(L & lock, const Duration & dur);
```
Same as timed_wait, but this function is modeled after the standard library interface and uses relative timeouts.

template<typename L, typename Duration, typename Pr> 
  bool wait_for(L & lock, const Duration & dur, Pr pred);

Same as timed_wait, but this function is modeled after the standard library interface and uses relative timeouts

Boost C++ Libraries