- Qt 6.4
- Qt Core
- C++ Classes
- QSemaphoreReleaser
- Qt 6.4.2 Reference Documentation

# QSemaphoreReleaser Class

The QSemaphoreReleaser class provides exception-safe deferral of a QSemaphore::release() call. More...

Header: | #include <QSemaphoreReleaser>
CMake: | find_package(Qt6 REQUIRED COMPONENTS Core) target_link_libraries(mytarget PRIVATE Qt6::Core)
qmake: | QT += core
Since: | Qt 5.10

- List of all members, including inherited members

Note: All functions in this class are reentrant.

## Public Functions

| QSemaphoreReleaser(QSemaphoreReleaser &&other)
| QSemaphoreReleaser(QSemaphore *sem, int n = 1)
| QSemaphoreReleaser(QSemaphore &sem, int n = 1)
| QSemaphoreReleaser()
QSemaphoreReleaser & | operator=(QSemaphoreReleaser &&other)
| ~QSemaphoreReleaser()
QSemaphore * | cancel()
QSemaphore * | semaphore() const
void | swap(QSemaphoreReleaser &other)

## Detailed Description

QSemaphoreReleaser can be used wherever you would otherwise use QSemaphore::release(). Constructing a QSemaphoreReleaser defers the release() call on the semaphore until the QSemaphoreReleaser is destroyed (see RAII pattern).

You can use this to reliably release a semaphore to avoid dead-lock in the face of exceptions or early returns:

     // ... do something that may throw or return early
     sem.release();

If an early return is taken or an exception is thrown before the `sem.release()` call is reached, the semaphore is not released, possibly preventing the thread waiting in the corresponding `sem.acquire()` call from ever continuing execution.

When using RAII instead:

     const QSemaphoreReleaser releaser(sem);
     // ... do something that may throw or early return
     // implicitly calls sem.release() here and at every other return in between

this can no longer happen, because the compiler will make sure that the QSemaphoreReleaser destructor is always called, and therefore the semaphore is always released.

QSemaphoreReleaser is move-enabled and can therefore be returned from functions to transfer responsibility for releasing a semaphore out of a function or a scope:

     { // some scope
         QSemaphoreReleaser releaser; // does nothing
         // ...
         if (someCondition) {
             releaser = QSemaphoreReleaser(sem);
             // ...
         }
         // ...
     } // conditionally calls sem.release(), depending on someCondition

A QSemaphoreReleaser can be canceled by a call to cancel(). A canceled semaphore releaser will no longer call QSemaphore::release() in its destructor.

See also QMutexLocker.

## Member Function Documentation

### QSemaphoreReleaser::QSemaphoreReleaser(QSemaphoreReleaser &&other)

Move constructor. Takes over responsibility to call QSemaphore::release() from other, which in turn is canceled.

See also cancel().

### QSemaphoreReleaser::QSemaphoreReleaser(QSemaphore *sem, int n = 1)

Constructor. Stores the arguments and calls sem->release(n) in the destructor.

### QSemaphoreReleaser::QSemaphoreReleaser(QSemaphore &sem, int n = 1)

Constructor. Stores the arguments and calls sem.release(n) in the destructor.

### QSemaphoreReleaser::QSemaphoreReleaser()

Default constructor. Creates a QSemaphoreReleaser that does nothing.

### QSemaphoreReleaser &QSemaphoreReleaser::operator=(QSemaphoreReleaser &&other)

Move assignment operator. Takes over responsibility to call QSemaphore::release() from other, which in turn is canceled.

If this semaphore releaser had the responsibility to call some QSemaphore::release() itself, it performs the call before taking over from other.

See also cancel().

### QSemaphoreReleaser::~QSemaphoreReleaser()

Unless canceled, calls QSemaphore::release() with the arguments provided to the constructor, or by the last move assignment.

### QSemaphore *QSemaphoreReleaser::cancel()

Cancels this QSemaphoreReleaser such that the destructor will no longer call `semaphore()->release()`. Returns the value of semaphore() before this call. After this call, semaphore() will return `nullptr`.

To enable again, assign a new QSemaphoreReleaser:

     releaser.cancel(); // avoid releasing old semaphore()
     releaser = QSemaphoreReleaser(sem, 42);
     // now will call sem.release(42) when 'releaser' is destroyed

### QSemaphore *QSemaphoreReleaser::semaphore() const

Returns a pointer to the QSemaphore object provided to the constructor, or by the last move assignment, if any. Otherwise, returns `nullptr`.

### void QSemaphoreReleaser::swap(QSemaphoreReleaser &other)

Exchanges the responsibilities of `*this` and other.

Unlike move assignment, neither of the two objects ever releases its semaphore, if any, as a consequence of swapping.

Therefore this function is very fast and never fails.