ReactiveRWLock (reactor-locks 1.1.0)

java.lang.Object
- party.iroiro.lock.ReactiveRWLock

All Implemented Interfaces:

Lock, RWLock
```
public final class ReactiveRWLock
extends Object
```
An implementation RWLock. See the Javadoc of Lock and RWLock for details.
This implementation handles writer hunger. A waiting writer should block (in reactive ways, of course) further readers from acquiring the lock.

Implemented with CAS operations (i.e., non-blocking).

Constructor Summary

Constructors
Constructor and Description

ReactiveRWLock()

Constructors
Constructor and Description
`ReactiveRWLock()`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`boolean`	`isLocked()` Checks whether this lock is locked (or has reached the max lock holders)
`boolean`	`isRLocked()` Checks whether this lock is reader-locked (or has reached the max lock holders)
`Mono<Void>`	`lock()` Get a `Mono` that emits success only after acquiring the lock
`<T> Mono<T>`	`lockOnNext(Mono<T> mono)` Try to acquire the lock on the next element before propagating
`Mono<Void>`	`rLock()` See `AbstractLock.lock()` for details.
`<T> Mono<T>`	`rLockOnNext(Mono<T> mono)` Tries to acquire the reader lock on the next element before propagating
`void`	`rUnlock()` See `Lock.unlock()` for details.
`<T> Mono<T>`	`rUnlockOnEmpty(Mono<T> mono)` See `AbstractLock.unlockOnEmpty(Mono)` for details.
`<T> Mono<T>`	`rUnlockOnError(Mono<T> mono)` See `AbstractLock.unlockOnError(Mono)` for details.
`<T> Mono<T>`	`rUnlockOnNext(Mono<T> mono)` See `AbstractLock.unlockOnNext(Mono)` for details.
`<T> Mono<T>`	`rUnlockOnTerminate(Mono<T> mono)` See `AbstractLock.unlockOnTerminate(Mono)` for details.
`LockHandle`	`tryLock()` Immediately requests to hold the lock.
`Mono<Void>`	`tryLock(Duration duration)` Tries to acquire the lock, or stop and propagate a `TimeoutException` downstream after certain duration.
`LockHandle`	`tryRLock()` The reader lock equivalent to `Lock.tryLock()`
`Mono<Void>`	`tryRLock(Duration duration)` Tries to acquire the reader-lock, or stop and propagate a `TimeoutException` downstream after certain duration.
`void`	`unlock()` Unlocks
`<T> Mono<T>`	`unlockOnEmpty(Mono<T> mono)` Release the lock with `Mono.switchIfEmpty(Mono)`
`<T> Mono<T>`	`unlockOnError(Mono<T> mono)` Release the lock with `Mono.doOnError(Consumer)` before propagating
`<T> Mono<T>`	`unlockOnNext(Mono<T> mono)` Release the lock with `Mono.doOnNext(Consumer)` before propagating
`<T> Mono<T>`	`unlockOnTerminate(Mono<T> mono)` Release the lock with `Mono.doOnTerminate(Runnable)` before propagating
`<T> Flux<T>`	`withLock(Supplier<Publisher<T>> scoped)` Automatically acquires the lock, executes the function and unlocks.
`<T> Flux<T>`	`withRLock(Supplier<Publisher<T>> scoped)` The reader lock version of `Lock.withLock(Supplier)`.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface party.iroiro.lock.Lock
begin, lock, lockOnNext, tryLock, unlockOnEmpty, unlockOnError, unlockOnNext, unlockOnTerminate, withLock

- Constructor Detail
  - ReactiveRWLock
```
public ReactiveRWLock()
```
- Method Detail
  - tryLock
```
public LockHandle tryLock()
```
    Description copied from interface: Lock
    
    Immediately requests to hold the lock.
    See LockHandle. Subscribe to LockHandle.mono() to get informed when the lock becomes available.
    
    To properly unlock, you are suggested to handle all cases including completing without error, failing with errors or the whole Mono or Flux getting cancelled. You might want to use Lock.withLock(Supplier) to save yourself from the boilerplate, which internally uses Flux.using(Callable, Function, Consumer) to LockHandle.cancel() or Lock.unlock() accordingly.
    
    Returns:
    
    a lock handle
  - tryRLock
```
public LockHandle tryRLock()
```
    Description copied from interface: RWLock
    
    The reader lock equivalent to Lock.tryLock()
    See LockHandle and Lock.tryLock()
    
    Returns:
    
    a lock handle
  - unlock
```
public void unlock()
```
    Description copied from interface: Lock
    Unlocks
    Usage:
```
     Lock lock = new ReactiveLock(); /* Or other locks */
     mono
         .transform(lock::lockOnNext)
         .flatMap(item -> {
             /* Some processing */
             lock.unlock();
             return Mono.just(item);
         })
         .block();
 
```
  - rUnlock
```
public void rUnlock()
```
    Description copied from interface: RWLock
    
    See Lock.unlock() for details.
  - isLocked
```
public boolean isLocked()
```
    Description copied from interface: Lock
    
    Checks whether this lock is locked (or has reached the max lock holders)
    You should not rely on the result of this due to possible concurrent operations.
    
    Returns:
    
    whether this lock is locked
  - isRLocked
```
public boolean isRLocked()
```
    Description copied from interface: RWLock
    
    Checks whether this lock is reader-locked (or has reached the max lock holders)
    You should not rely on the result of this due to possible concurrent operations.
    
    Returns:
    
    whether this lock is reader-locked
  - tryRLock
```
public Mono<Void> tryRLock(Duration duration)
```
    Description copied from interface: RWLock
    
    Tries to acquire the reader-lock, or stop and propagate a TimeoutException downstream after certain duration.
    
    Specified by:
    
    tryRLock in interface RWLock
    
    Parameters:
    
    duration - the time to wait for lock
    
    Returns:
    
    a Mono that emits success when the lock is acquired
  - withRLock
```
public <T> Flux<T> withRLock(Supplier<Publisher<T>> scoped)
```
    Description copied from interface: RWLock
    
    The reader lock version of Lock.withLock(Supplier).
    
    Specified by:
    
    withRLock in interface RWLock
    
    Type Parameters:
    
    T - the flowing data type
    
    Parameters:
    
    scoped - the function to get executed with the lock held
    
    Returns:
    
    a Flux containing values produces by the Publisher returned by the function
  - rLock
```
public Mono<Void> rLock()
```
    Description copied from interface: RWLock
    
    See AbstractLock.lock() for details.
    
    Specified by:
    
    rLock in interface RWLock
    
    Returns:
    
    a Mono that emits success when the lock is acquired
  - rLockOnNext
```
public <T> Mono<T> rLockOnNext(Mono<T> mono)
```
    Description copied from interface: RWLock
    
    Tries to acquire the reader lock on the next element before propagating
    
    Specified by:
    
    rLockOnNext in interface RWLock
    
    Type Parameters:
    
    T - the generic type of Mono
    
    Parameters:
    
    mono - the Mono, of which the next value will require locking to propagate
    
    Returns:
    
    the transformed Mono
  - rUnlockOnEmpty
```
public <T> Mono<T> rUnlockOnEmpty(Mono<T> mono)
```
    Description copied from interface: RWLock
    
    See AbstractLock.unlockOnEmpty(Mono) for details.
    
    Specified by:
    
    rUnlockOnEmpty in interface RWLock
    
    Type Parameters:
    
    T - the generic type of Mono
    
    Parameters:
    
    mono - the Mono, of which the next signal, when Mono is empty, will require unlocking to propagate
    
    Returns:
    
    the transformed Mono
  - rUnlockOnNext
```
public <T> Mono<T> rUnlockOnNext(Mono<T> mono)
```
    Description copied from interface: RWLock
    
    See AbstractLock.unlockOnNext(Mono) for details.
    
    Specified by:
    
    rUnlockOnNext in interface RWLock
    
    Type Parameters:
    
    T - the generic type of Mono
    
    Parameters:
    
    mono - the Mono, of which the next value will require unlocking to propagate
    
    Returns:
    
    the transformed Mono
  - rUnlockOnTerminate
```
public <T> Mono<T> rUnlockOnTerminate(Mono<T> mono)
```
    Description copied from interface: RWLock
    
    See AbstractLock.unlockOnTerminate(Mono) for details.
    
    Specified by:
    
    rUnlockOnTerminate in interface RWLock
    
    Type Parameters:
    
    T - the generic type of Mono
    
    Parameters:
    
    mono - the Mono, of which the termination signal will require unlocking to propagate
    
    Returns:
    
    the transformed Mono
  - rUnlockOnError
```
public <T> Mono<T> rUnlockOnError(Mono<T> mono)
```
    Description copied from interface: RWLock
    
    See AbstractLock.unlockOnError(Mono) for details.
    
    Specified by:
    
    rUnlockOnError in interface RWLock
    
    Type Parameters:
    
    T - the generic type of Mono
    
    Parameters:
    
    mono - the Mono, of which the next error will require unlocking to propagate
    
    Returns:
    
    the transformed Mono
  - tryLock
```
public Mono<Void> tryLock(Duration duration)
```
    Description copied from interface: Lock
    
    Tries to acquire the lock, or stop and propagate a TimeoutException downstream after certain duration.
    
    Specified by:
    
    tryLock in interface Lock
    
    Parameters:
    
    duration - the time to wait for lock
    
    Returns:
    
    a Mono that emits success when the lock is acquired
  - lock
```
public Mono<Void> lock()
```
    Description copied from interface: Lock
    
    Get a Mono that emits success only after acquiring the lock
    
    Specified by:
    
    lock in interface Lock
    
    Returns:
    
    a Mono that emits success when the lock is acquired
  - withLock
```
public <T> Flux<T> withLock(Supplier<Publisher<T>> scoped)
```
    Description copied from interface: Lock
    
    Automatically acquires the lock, executes the function and unlocks.
    It handles all cases including when the Flux completes without error (empty or not), fails with errors, or gets cancelled middle way.
    
    Specified by:
    
    withLock in interface Lock
    
    Type Parameters:
    
    T - the flowing data type
    
    Parameters:
    
    scoped - a Publisher supplier to be run with the lock held
    
    Returns:
    
    a Flux containing values produces by the Publisher returned by the function
  - lockOnNext
```
public <T> Mono<T> lockOnNext(Mono<T> mono)
```
    Description copied from interface: Lock
    
    Try to acquire the lock on the next element before propagating
    
    Specified by:
    
    lockOnNext in interface Lock
    
    Type Parameters:
    
    T - the generic type of Mono
    
    Parameters:
    
    mono - the Mono, of which the next value will require locking to propagate
    
    Returns:
    
    the transformed Mono
  - unlockOnTerminate
```
public <T> Mono<T> unlockOnTerminate(Mono<T> mono)
```
    Description copied from interface: Lock
    
    Release the lock with Mono.doOnTerminate(Runnable) before propagating
    
    Specified by:
    
    unlockOnTerminate in interface Lock
    
    Type Parameters:
    
    T - the generic type of Mono
    
    Parameters:
    
    mono - the Mono, of which the termination signal will require unlocking to propagate
    
    Returns:
    
    the transformed Mono
  - unlockOnNext
```
public <T> Mono<T> unlockOnNext(Mono<T> mono)
```
    Description copied from interface: Lock
    
    Release the lock with Mono.doOnNext(Consumer) before propagating
    
    Specified by:
    
    unlockOnNext in interface Lock
    
    Type Parameters:
    
    T - the generic type of Mono
    
    Parameters:
    
    mono - the Mono, of which the next value will require unlocking to propagate
    
    Returns:
    
    the transformed Mono
  - unlockOnEmpty
```
public <T> Mono<T> unlockOnEmpty(Mono<T> mono)
```
    Description copied from interface: Lock
    
    Release the lock with Mono.switchIfEmpty(Mono)
    
    Specified by:
    
    unlockOnEmpty in interface Lock
    
    Type Parameters:
    
    T - the generic type of Mono
    
    Parameters:
    
    mono - the Mono, of which the signal, when Mono is empty, will require unlocking to propagate
    
    Returns:
    
    the transformed Mono
  - unlockOnError
```
public <T> Mono<T> unlockOnError(Mono<T> mono)
```
    Description copied from interface: Lock
    
    Release the lock with Mono.doOnError(Consumer) before propagating
    
    Specified by:
    
    unlockOnError in interface Lock
    
    Type Parameters:
    
    T - the generic type of Mono
    
    Parameters:
    
    mono - the Mono, of which the next error will require unlocking to propagate
    
    Returns:
    
    the transformed Mono

Class ReactiveRWLock

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface party.iroiro.lock.Lock

Constructor Detail

ReactiveRWLock

Method Detail

tryLock

tryRLock

unlock

rUnlock

isLocked

isRLocked

tryRLock

withRLock

rLock

rLockOnNext

rUnlockOnEmpty

rUnlockOnNext

rUnlockOnTerminate

rUnlockOnError

tryLock

lock

withLock

lockOnNext

unlockOnTerminate

unlockOnNext

unlockOnEmpty

unlockOnError