/// Creates a new futures-aware semaphore.
///
/// `is_fair` defines whether the `Semaphore` should behave be fair regarding the
/// order of waiters. A fair `Semaphore` will only allow the oldest waiter on
/// a `Semaphore` to retry acquiring it once it's available again.
/// Other waiters must wait until either this acquire attempt completes, and
/// the `Semaphore` has enough permits after that, or until the
/// [`SemaphoreAcquireFuture`] which tried to acquire the `Semaphore` is dropped.
///
/// If the `Semaphore` isn't fair, waiters that wait for a high amount of
/// permits might never succeed since the permits might be stolen in between
/// by other waiters. Therefore use-cases which make use of very different
/// amount of permits per acquire should use fair semaphores.
/// For use-cases where each `acquire()` tries to acquire the same amount of
/// permits an unfair `Semaphore` might provide throughput advantages.
///
/// `permits` is the amount of permits that a semaphore should hold when
/// created.
Creates a new futures-aware semaphore.
`is_fair` defines whether the `Semaphore` should behave be fair regarding the
order of waiters. A fair `Semaphore` will only allow the oldest waiter on
a `Semaphore` to retry acquiring it once it's available again.

If the `Semaphore` isn't fair, waiters that wait for a high amount of
permits might never succeed since the permits might be stolen in between
by other waiters. Therefore use-cases which make use of very different
amount of permits per acquire should use fair semaphores.
For use-cases where each `acquire()` tries to acquire the same amount of
permits an unfair `Semaphore` might provide throughput advantages.

`permits` is the amount of permits that a semaphore should hold when
created.
Creates a new futures - aware semaphore . ` is_fair ` defines whether the ` Semaphore ` should behave be fair regarding the order of waiters . A fair ` Semaphore ` will only allow the oldest waiter on a ` Semaphore ` to retry acquiring it once it ' s available again . If the ` Semaphore ` isn ' t fair waiters that wait for a high amount of permits might never succeed since the permits might be stolen in between by other waiters . Therefore use - cases which make use of very different amount of permits per acquire should use fair semaphores . For use - cases where each ` acquire () ` tries to acquire the same amount of permits an unfair ` Semaphore ` might provide throughput advantages . ` permits ` is the amount of permits that a semaphore should hold when created .
pub fn new(is_fair: bool, permits: usize) -> GenericSemaphore<MutexType> {
        GenericSemaphore::<MutexType> {
            state: LockApiMutex::new(SemaphoreState::new(is_fair, permits)),
        }
    }
pub fn new ( is_fair : bool , permits : usize ) -> GenericSemaphore < MutexType > { GenericSemaphore :: < MutexType > { state : LockApiMutex :: new ( SemaphoreState :: new ( is_fair , permits ) ) , } }
Creates a new futures-aware semaphore.
Creates a new futures - aware semaphore .
is_fair
bool
permits
usize