scoped_lock();

Эффекты: По умолчанию строит<scoped_lock>. Постусловия: owns() == false и mutex() == 0.

explicitscoped_lock(mutex_type&m);

Эффекты: m.lock(). Постусловия: owns() == true и mutex() == &m. Примечания: Конструктор получит право собственности на мутекс. Если другой поток уже владеет mutex, этот поток будет блокироваться до тех пор, пока mutex не будет выпущен. Независимо от того, обрабатывает ли этот конструктор рекурсивную блокировку, зависит от мутекса.

scoped_lock(mutex_type&m,defer_lock_type);

Постусловия: owns() == false, и mutex() == &m. Примечания: Конструктор не будет владеть мутексом. Не требуется никакого влияния на упомянутый мутекс.

scoped_lock(mutex_type&m,accept_ownership_type);

Постусловия: владеет() == истинно, и mutex() == &m. Примечания: Конструктор будет предполагать, что мутекс уже заблокирован. Не требуется никакого влияния на упомянутый мутекс.

scoped_lock(mutex_type&m,try_to_lock_type);

Эффекты: m.try_lock(). Постусловия: mutex() == &m. owns() == возвращаемое значение m.try_lock(), выполненное внутри конструктора. Примечания: Конструктор получит право собственности на мутекс, если сможет сделать это, не дожидаясь. Независимо от того, обрабатывает ли этот конструктор рекурсивную блокировку, зависит от мутекса. Если mutex_type не поддерживает try_lock, этот конструктор потерпит неудачу во время компиляции, если будет реализован, но в противном случае не будет иметь никакого эффекта.

scoped_lock(mutex_type&m,constboost::posix_time::ptime&abs_time);

Эффекты: m.timed_lock (abs_time). Постусловия: mutex() == &m. owns() == возвращаемое значение m.timed_lock(abs_time), выполненного внутри конструктора. Примечания: Конструктор получит право собственности на mutex, если он сможет это сделать, пока не будет достигнуто время abs_. Независимо от того, обрабатывает ли этот конструктор рекурсивную блокировку, зависит от мутекса. Если mutex_type не поддерживает try_lock, этот конструктор потерпит неудачу во время компиляции, если будет реализован, но в противном случае не будет иметь никакого эффекта.

scoped_lock(scoped_lock&&scop);

Постусловия: mutex() == значение scop.mutex() до выполнения конструктором. s1.mutex() == 0. owns() == значение scop.owns() до выполнения конструктором. scop.owns(). Примечания: Если scop<scoped_lock>владеет mutex, право собственности перемещается в thisscoped_lock без блокировки. Если же<scoped_lock>не владеет мутексом, то и это<scoped_lock>не будет. Только перемещенное<scoped_lock>будет соответствовать этой подписи. Неподвижный<scoped_lock>может быть перемещен с выражением: «буст::движение (блок);». Этот конструктор не изменяет состояние мутекса, только потенциально владеющий им.

template<typenameT>
 explicitscoped_lock(upgradable_lock<T>&&upgr,unspecified=0);

Эффекты: если upgr.owns() вызывает разблокировку_upgradable_and_lock() на mutex. upgr.release() mutex() == значение upgr.mutex() до начала строительства. upgr.mutex() == 0. owns() == upgr.owns() перед строительством. upgr.owns() == false after the construction. Примечания: Если он запирается, то этот конструктор запирает его<scoped_lock>при разблокировке. Если же он будет разблокирован, то это<scoped_lock>тоже будет разблокировано. Только перемещенное<upgradable_lock>будет соответствовать этой подписи. Неподвижный<upgradable_lock>может быть перемещен с выражением: «буст::движение (блок);» Этот конструктор может блокировать, если другие потоки удерживают<sharable_lock>на этом mutex<sharable_lock>'s могут совместно владеть<upgradable_lock>.

template<typenameT>
 scoped_lock(upgradable_lock<T>&&upgr,try_to_lock_type,unspecified=0);

Эффекты: если upgr.owns() затем вызывает try_unlock_upgradable_and_lock() на упоминаемом mutex: a) если try_unlock_upgradable_and_lock() возвращает истинное, то mutex() получает значение от upgr.release() и owns() устанавливается на истинное. b) если try_unlock_upgradable_and_lock() возвращает ложные данные, то upgr не затрагивается, и эта<scoped_lock>конструкция имеет те же последствия, что и конструкция по умолчанию. c) Else upgr.owns() является ложным. mutex() получает значение от upgr.release() и владеет() устанавливается на ложные Примечания: Эта конструкция не будет блокироваться. Он попытается немедленно получить право собственности на mutex, изменив тип замка с «замка чтения» на «замок записи». Если «замок чтения» не удерживается в первую очередь, mutex просто меняет тип на разблокированный «замок записи». Если «блокировка чтения» удерживается, то передача mutex происходит только в том случае, если она может сделать это неблокирующим образом.

template<typenameT>
 scoped_lock(upgradable_lock<T>&&upgr,
             boost::posix_time::ptime&abs_time,unspecified=0);

Эффекты: если upgr.owns() затем вызывает timed_unlock_upgradable_and_lock(abs_time) на упоминаемом mutex: a) если timed_unlock_upgradable_and_lock(abs_time) возвращает истинное, то mutex() получает значение от upgr.release() и owns() устанавливается на истинное. (b) если таймд_unlock_upgradable_and_lock(abs_time) возвращает ложное, то upgr не затрагивается, и эта<scoped_lock>конструкция имеет те же эффекты, что и конструкция по умолчанию. c) Else upgr.owns() является ложным. mutex() получает значение от upgr.release() и владеет() устанавливается на ложные Примечания: Эта конструкция не будет блокироваться. Он попытается немедленно получить право собственности на mutex, изменив тип замка с «замка чтения» на «замок записи». Если «замок чтения» не удерживается в первую очередь, mutex просто меняет тип на разблокированный «замок записи». Если «блокировка чтения» удерживается, то передача mutex происходит только в том случае, если она может сделать это неблокирующим образом.

template<typenameT>
 scoped_lock(sharable_lock<T>&&shar,try_to_lock_type,unspecified=0);

Эффекты: если shar.owns() затем вызывает try_unlock_sharable_and_lock() на упоминаемом mutex. a) если try_unlock_sharable_and_lock() возвращает истинное, то mutex() получает значение от shar.release() и owns() устанавливается на истинное. b) если try_unlock_sharable_and_lock() возвращает ложное, то шар не затрагивается, и эта<scoped_lock>конструкция имеет те же эффекты, что и конструкция по умолчанию. c) Else shar.owns() является ложным. mutex() получает значение от shar.release() и owns() устанавливается на ложные примечания: Эта конструкция не будет блокироваться. Он попытается немедленно получить право собственности на mutex от Shar, изменив тип замка с «замка чтения» на «замок записи». Если «замок чтения» не удерживается в первую очередь, mutex просто меняет тип на разблокированный «замок записи». Если «блокировка чтения» удерживается, то передача mutex происходит только в том случае, если она может сделать это неблокирующим образом.

scoped_lock&operator=(scoped_lock&&scop);

Эффекты: если владеет() перед вызовом, то разблокировка() вызывается на mutex(). * это приводит к состоянию scop, а scop устанавливается в состояние, построенное по умолчанию. Примечания: С рекурсивным мутексом возможно, что и этот, и скоп владеют одним и тем же мутексом до назначения. В этом случае, это будет владеть mutex после назначения (и scop не будет), но количество блокировки mutex будет уменьшено одним.

~scoped_lock();

Эффекты: если (владеет()) mp_mutex->unlock(). Примечания: Поведение деструктора гарантирует, что замок mutex не просочился.

voidlock();

Эффекты: если mutex() == 0 или если уже заблокирован, бросает блокировку_исключение() исключение. Calls lock() на упоминаемом mutex. Пост-условия: Собственность () == истинно. Примечания:<scoped_lock>изменяется от состояния невладения мутексом к владению мутексом, блокируя при необходимости.

*booltry_lock();

Эффекты: если mutex() == 0 или если уже заблокирован, бросает блокировку_исключение() исключение. Вызовы try_lock() по адресу mutex. Постусловия: владеет() == значение, возвращенное из mutex()->try_lock(). Примечания:<scoped_lock>изменяется от состояния невладения мутексом к владению мутексом, но только если блокировка не требуется. Если mutex_type не поддерживает try_lock(), эта функция не сработает во время компиляции, если она будет реализована.

*booltimed_lock(constboost::posix_time::ptime&abs_time);

Эффекты: если mutex() == 0 или если уже заблокирован, бросает блокировку_исключение() исключение. Вызовы timed_lock(abs_time) по адресу mutex. Постусловия: владеет() == значение, возвращенное из mutex()->timed_lock(abs_time). Примечания:<scoped_lock>изменяется от состояния невладения мутексом к владению мутексом, но только если он может получить право собственности к указанному времени. Если mutex_type не поддерживает timed_lock (), эта функция выйдет из строя во время компиляции, если она будет реализована, но в противном случае не будет иметь никакого эффекта.

*voidunlock();

Эффекты: если mutex() == 0 или если не заперта, бросает блокировку_исключение() исключение. Calls unlock() on the referenced mutex. Собственные () == ложные. Примечания:<scoped_lock>изменяется от состояния владения мутексом к невладению мутексом.

boolowns()const;

Эффекты: Возвращается истинно, если это<scoped_lock>приобрело упомянутый мутекс.

operatorunspecified_bool_type()const;

Превращение в бул. Возврат собственных ().

mutex_type*mutex()const;

Эффекты: возвращает указатель на упомянутый мутекс, или 0, если нет мутекса для ссылки.

mutex_type*release();

Эффекты: возвращает указатель на упомянутый мутекс, или 0, если нет мутекса для ссылки. Постусловия: mutex() == 0 и owns() == false

voidswap(scoped_lock<mutex_type>&other);

Эффекты: состояние свопса с перемещаемым замком. Бросок: ничего.