SemaphoreClientProxy (Hazelcast Root 2.6.3 API)

java.lang.Object
- com.hazelcast.client.SemaphoreClientProxy

All Implemented Interfaces:: Instance, ISemaphore

public class SemaphoreClientProxy
extends Object
implements ISemaphore

Nested Class Summary
- Nested classes/interfaces inherited from interface com.hazelcast.core.Instance
  Instance.InstanceType

Constructor Summary

Constructors
Constructor and Description

SemaphoreClientProxy(HazelcastClient hazelcastClient, String name)

Constructors
Constructor and Description
`SemaphoreClientProxy(HazelcastClient hazelcastClient, String name)`

Method Summary

Methods
Modifier and Type	Method and Description
`void`	`acquire()` Acquires a permit, if one is available and returns immediately, reducing the number of available permits by one.
`void`	`acquire(int permits)` Acquires the given number of permits, if they are available, and returns immediately, reducing the number of available permits by the given amount.
`Future`	`acquireAsync()` Asynchronously acquires a permit.
`Future`	`acquireAsync(int permits)` Asynchronously acquires a given number of permits.
`void`	`acquireAttach()` Acquires and attaches a permit to the caller's address.
`void`	`acquireAttach(int permits)` Acquires and attaches the given number of permits to the caller's address.
`Future`	`acquireAttachAsync()` Asynchronously acquires and attaches a permit to the caller's address.
`Future`	`acquireAttachAsync(int permits)` Asynchronously acquires and attaches the given number of permits to the caller's address.
`void`	`attach()` Attaches a permit to the caller's address.
`void`	`attach(int permits)` Attaches the given number of permits to the caller's address.
`int`	`attachedPermits()` Returns the current number of permits attached to the caller's address.
`int`	`availablePermits()` Returns the current number of permits currently available in this semaphore.
`void`	`destroy()` Destroys this instance cluster-wide.
`void`	`detach()` Detaches a permit from the caller's address.
`void`	`detach(int permits)` Detaches the given number of permits from the caller's address.
`int`	`drainPermits()` Acquires and returns all permits that are immediately available.
`Object`	`getId()` Returns the unique id for this instance.
`Instance.InstanceType`	`getInstanceType()` Returns instance type such as map, set, list, lock, topic, multimap, id generator
`LocalSemaphoreStats`	`getLocalSemaphoreStats()`
`String`	`getName()` Returns the name of this ISemaphore instance.
`void`	`reducePermits(int permits)` Shrinks the number of available permits by the indicated reduction.
`void`	`release()` Releases a permit, increasing the number of available permits by one.
`void`	`release(int permits)` Releases the given number of permits, increasing the number of available permits by that amount.
`void`	`releaseDetach()` Detaches a permit from the caller's address and returns it to the semaphore.
`void`	`releaseDetach(int permits)` Detaches the given number of permits from the caller's address and returns them to the semaphore.
`boolean`	`tryAcquire()` Acquires a permit, if one is available and returns immediately, with the value `true`, reducing the number of available permits by one.
`boolean`	`tryAcquire(int permits)` Acquires the given number of permits, if they are available, and returns immediately, with the value `true`, reducing the number of available permits by the given amount.
`boolean`	`tryAcquire(int permits, long timeout, TimeUnit unit)` Acquires the given number of permits, if they are available and returns immediately, with the value `true`, reducing the number of available permits by the given amount.
`boolean`	`tryAcquire(long timeout, TimeUnit unit)` Acquires a permit from this semaphore, if one becomes available within the given waiting time and the current thread has not been interrupted.
`boolean`	`tryAcquireAttach()` Acquires a permit from this semaphore and attaches it to the calling member, only if one is available at the time of invocation.
`boolean`	`tryAcquireAttach(int permits)` Acquires the given number of permits from this semaphore and attaches them to the calling member, only if all are available at the time of invocation.
`boolean`	`tryAcquireAttach(int permits, long timeout, TimeUnit unit)` Acquires the given number of permits from this semaphore and attaches them to the calling member, only if all become available within the given waiting time and the current thread has not been interrupted or the instance destroyed.
`boolean`	`tryAcquireAttach(long timeout, TimeUnit unit)` Acquires a permit from this semaphore and attaches it to the calling member, only if one becomes available within the given waiting time and the current thread has not been interrupted or the instance destroyed.

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

- Constructor Detail
  - SemaphoreClientProxy
```
public SemaphoreClientProxy(HazelcastClient hazelcastClient,
                    String name)
```
- Method Detail
  - acquire
```
public void acquire()
             throws InstanceDestroyedException,
                    InterruptedException
```
    Description copied from interface: ISemaphore
    Acquires a permit, if one is available and returns immediately, reducing the number of available permits by one.
    
    If no permit is available then the current thread becomes disabled for thread scheduling purposes and lies dormant until one of three things happens:
    - Some other thread invokes one of the ISemaphore.release() methods for this semaphore and the current thread is next to be assigned a permit;
    - This ISemaphore instance is destroyed; or
    - Some other thread interrupts the current thread.
    If the ISemaphore instance is destroyed while the thread is waiting then InstanceDestroyedException will be thrown.
    If the current thread:
    - has its interrupted status set on entry to this method; or
    - is interrupted while waiting for a permit,
    then InterruptedException is thrown and the current thread's interrupted status is cleared.
    Specified by:
    
    acquire in interface ISemaphore
    
    Throws:
    
    InstanceDestroyedException - if the instance is destroyed while waiting
    
    InterruptedException - if the current thread is interrupted
  - acquire
```
public void acquire(int permits)
             throws InstanceDestroyedException,
                    InterruptedException
```
    Description copied from interface: ISemaphore
    Acquires the given number of permits, if they are available, and returns immediately, reducing the number of available permits by the given amount.
    
    If insufficient permits are available then the current thread becomes disabled for thread scheduling purposes and lies dormant until one of three things happens:
    - Some other thread invokes one of the release methods for this semaphore, the current thread is next to be assigned permits and the number of available permits satisfies this request;
    - This ISemaphore instance is destroyed; or
    - Some other thread interrupts the current thread.
    If the ISemaphore instance is destroyed while waiting then InstanceDestroyedException will be thrown.
    If the current thread:
    - has its interrupted status set on entry to this method; or
    - is interrupted while waiting for a permit,
    then InterruptedException is thrown and the current thread's interrupted status is cleared.
    Specified by:
    
    acquire in interface ISemaphore
    
    Parameters:
    permits - the number of permits to acquire
    
    Throws:
    
    InstanceDestroyedException - if the instance is destroyed while waiting
    
    InterruptedException - if the current thread is interrupted
  - acquireAsync
```
public Future acquireAsync()
```
    Description copied from interface: ISemaphore
    Asynchronously acquires a permit.
```
 Future future = semaphore.acquireAsync();
 // do some other stuff, when ready get the result
 Object value = future.get();
 
```
    Future.get() will block until the actual acquire() completes. If the application requires timely response, then Future.get(timeout, timeunit) can be used.
```
 Future future = semaphore.acquireAsync();
 try{
   Object value = future.get(40, TimeUnit.MILLISECOND);
 }catch (TimeoutException t) {
   // time wasn't enough
 }
 
```
    This method itself does not throw any exceptions. Exceptions occur during the future.get() operation.
    
    If insufficient permits are available when calling future.get() then the current thread becomes disabled for thread scheduling purposes and lies dormant until one of four things happens:
    - Some other thread invokes one of the release methods for this semaphore, the current thread is next to be assigned permits and the number of available permits satisfies this request;
    - This ISemaphore instance is destroyed;
    - The get method is called with a waiting time that elapses; or
    - Some other thread interrupts the current thread.
    If the ISemaphore instance is destroyed while the future.get() is waiting then ExecutionException will be thrown with InstanceDestroyedException set as it's cause.
    If the Hazelcast instance is shutdows while the future.get() is waiting then IllegalStateException will be thrown.
    If when calling future.get() a timeout is specified and the a permit cannot be acquired within the timeout period TimeoutException will be thrown.
    If when calling future.get() the current thread:
    - has its interrupted status set on entry to this method; or
    - is interrupted while waiting for a permit,
    then InterruptedException is thrown and the current thread's interrupted status is cleared.
    If the thread future.get() throws an InterruptedException, the acquire request is still outstanding and future.get() may be called again. To cancel the actual acquire, future.cancel() must be called. If the cancel method returns false then it was too late to cancel the request and the permit was acquired. The future.cancel() mayInterruptIfRunning argument is ignored.
    Specified by:
    
    acquireAsync in interface ISemaphore
    
    Returns:
    Future from which the acquire result can be obtained.
    See Also:
    Future
  - acquireAsync
```
public Future acquireAsync(int permits)
```
    Description copied from interface: ISemaphore
    
    Asynchronously acquires a given number of permits.
    See ISemaphore.acquireAsync().
    
    Specified by:
    
    acquireAsync in interface ISemaphore
    
    Parameters:
    permits - the number of permits to acquire
  - acquireAttach
```
public void acquireAttach()
                   throws InstanceDestroyedException,
                          InterruptedException
```
    Description copied from interface: ISemaphore
    
    Acquires and attaches a permit to the caller's address.
    See ISemaphore.acquire() and ISemaphore.attach().
    
    Specified by:
    
    acquireAttach in interface ISemaphore
    
    Throws:
    
    InstanceDestroyedException
    
    InterruptedException
  - acquireAttach
```
public void acquireAttach(int permits)
                   throws InstanceDestroyedException,
                          InterruptedException
```
    Description copied from interface: ISemaphore
    
    Acquires and attaches the given number of permits to the caller's address.
    See ISemaphore.acquire() and ISemaphore.attach().
    
    Specified by:
    
    acquireAttach in interface ISemaphore
    
    Parameters:
    permits - the number of permits to acquire and attach
    
    Throws:
    
    InstanceDestroyedException
    
    InterruptedException
  - acquireAttachAsync
```
public Future acquireAttachAsync()
```
    Description copied from interface: ISemaphore
    
    Asynchronously acquires and attaches a permit to the caller's address.
    See ISemaphore.acquireAsync() and ISemaphore.attach().
    
    Specified by:
    
    acquireAttachAsync in interface ISemaphore
  - acquireAttachAsync
```
public Future acquireAttachAsync(int permits)
```
    Description copied from interface: ISemaphore
    
    Asynchronously acquires and attaches the given number of permits to the caller's address.
    See ISemaphore.acquireAsync() and ISemaphore.attach().
    
    Specified by:
    
    acquireAttachAsync in interface ISemaphore
    
    Parameters:
    permits - the number of permits to acquire and attach
  - attach
```
public void attach()
```
    Description copied from interface: ISemaphore
    
    Attaches a permit to the caller's address.
    See ISemaphore.attachedPermits().
    
    Specified by:
    
    attach in interface ISemaphore
  - attach
```
public void attach(int permits)
```
    Description copied from interface: ISemaphore
    
    Attaches the given number of permits to the caller's address.
    See ISemaphore.attachedPermits().
    
    Specified by:
    
    attach in interface ISemaphore
    
    Parameters:
    permits - the number of permits to attach
  - attachedPermits
```
public int attachedPermits()
```
    Description copied from interface: ISemaphore
    Returns the current number of permits attached to the caller's address. This value has no affect on the semaphores operation unless the caller address actually becomes disconnected.
    Positive value is the number of permits that will automatically be released to the semaphore if the caller address becomes disconnected from the cluster.
    Negative value represents the number of permits that the semaphore will automatically be reduced by if the caller address becomes disconnected from the cluster.
    - This method is typically used for debugging and testing purposes.
    Specified by:
    
    attachedPermits in interface ISemaphore
    
    Returns:
    the number of permits attached to caller addresses
  - availablePermits
```
public int availablePermits()
```
    Description copied from interface: ISemaphore
    Returns the current number of permits currently available in this semaphore.
    - This method is typically used for debugging and testing purposes.
    Specified by:
    
    availablePermits in interface ISemaphore
    
    Returns:
    the number of permits available in this semaphore
  - detach
```
public void detach()
```
    Description copied from interface: ISemaphore
    
    Detaches a permit from the caller's address.
    See ISemaphore.attachedPermits().
    
    Specified by:
    
    detach in interface ISemaphore
  - detach
```
public void detach(int permits)
```
    Description copied from interface: ISemaphore
    
    Detaches the given number of permits from the caller's address.
    See ISemaphore.attachedPermits().
    
    Specified by:
    
    detach in interface ISemaphore
    
    Parameters:
    permits - the number of permits to detach
  - drainPermits
```
public int drainPermits()
```
    Description copied from interface: ISemaphore
    
    Acquires and returns all permits that are immediately available.
    
    Specified by:
    
    drainPermits in interface ISemaphore
    
    Returns:
    the number of permits drained
  - reducePermits
```
public void reducePermits(int permits)
```
    Description copied from interface: ISemaphore
    
    Shrinks the number of available permits by the indicated reduction. This method differs from acquire in that it does not block waiting for permits to become available.
    
    Specified by:
    
    reducePermits in interface ISemaphore
    
    Parameters:
    permits - the number of permits to remove
  - release
```
public void release()
```
    Description copied from interface: ISemaphore
    
    Releases a permit, increasing the number of available permits by one. If any threads in the cluster are trying to acquire a permit, then one is selected and given the permit that was just released.
    There is no requirement that a thread that releases a permit must have acquired that permit by calling one of the acquire methods. Correct usage of a semaphore is established by programming convention in the application.
    
    Specified by:
    
    release in interface ISemaphore
  - release
```
public void release(int permits)
```
    Description copied from interface: ISemaphore
    
    Releases the given number of permits, increasing the number of available permits by that amount.
    There is no requirement that a thread that releases a permit must have acquired that permit by calling one of the acquire methods. Correct usage of a semaphore is established by programming convention in the application.
    
    Specified by:
    
    release in interface ISemaphore
    
    Parameters:
    permits - the number of permits to release
  - releaseDetach
```
public void releaseDetach()
```
    Description copied from interface: ISemaphore
    
    Detaches a permit from the caller's address and returns it to the semaphore.
    See ISemaphore.release() and ISemaphore.detach().
    
    Specified by:
    
    releaseDetach in interface ISemaphore
  - releaseDetach
```
public void releaseDetach(int permits)
```
    Description copied from interface: ISemaphore
    
    Detaches the given number of permits from the caller's address and returns them to the semaphore.
    See ISemaphore.release(int) and ISemaphore.detach().
    
    Specified by:
    
    releaseDetach in interface ISemaphore
    
    Parameters:
    permits - the number of permits to release and detach
  - tryAcquire
```
public boolean tryAcquire()
```
    Description copied from interface: ISemaphore
    
    Acquires a permit, if one is available and returns immediately, with the value true, reducing the number of available permits by one.
    If no permit is available then this method will return immediately with the value false.
    
    Specified by:
    
    tryAcquire in interface ISemaphore
    
    Returns:
    true if a permit was acquired and false otherwise
  - tryAcquire
```
public boolean tryAcquire(int permits)
```
    Description copied from interface: ISemaphore
    
    Acquires the given number of permits, if they are available, and returns immediately, with the value true, reducing the number of available permits by the given amount.
    
    If insufficient permits are available then this method will return immediately with the value false and the number of available permits is unchanged.
    
    Specified by:
    
    tryAcquire in interface ISemaphore
    
    Parameters:
    permits - the number of permits to acquire
    
    Returns:
    true if the permits were acquired and false otherwise
  - tryAcquire
```
public boolean tryAcquire(long timeout,
                 TimeUnit unit)
                   throws InstanceDestroyedException,
                          InterruptedException
```
    Description copied from interface: ISemaphore
    Acquires a permit from this semaphore, if one becomes available within the given waiting time and the current thread has not been interrupted.
    Acquires a permit, if one is available and returns immediately, with the value true, reducing the number of available permits by one.
    If no permit is available then the current thread becomes disabled for thread scheduling purposes and lies dormant until one of three things happens:
    - Some other thread invokes the ISemaphore.release() method for this semaphore and the current thread is next to be assigned a permit; or
    - Some other thread interrupts the current thread; or
    - The specified waiting time elapses.
    If a permit is acquired then the value true is returned.
    If the specified waiting time elapses then the value false is returned. If the time is less than or equal to zero, the method will not wait at all.
    
    If the ISemaphore instance is destroyed while the thread is waiting then InstanceDestroyedException will be thrown.
    If the current thread:
    - has its interrupted status set on entry to this method; or
    - is interrupted while waiting for a permit,
    then InterruptedException is thrown and the current thread's interrupted status is cleared.
    Specified by:
    
    tryAcquire in interface ISemaphore
    
    Parameters:
    timeout - the maximum time to wait for a permit
    unit - the time unit of the timeout argument
    
    Returns:
    true if a permit was acquired and false if the waiting time elapsed before a permit was acquired
    
    Throws:
    
    InstanceDestroyedException - if the instance is destroyed while waiting
    
    InterruptedException - if the current thread is interrupted
  - tryAcquire
```
public boolean tryAcquire(int permits,
                 long timeout,
                 TimeUnit unit)
                   throws InstanceDestroyedException,
                          InterruptedException
```
    Description copied from interface: ISemaphore
    Acquires the given number of permits, if they are available and returns immediately, with the value true, reducing the number of available permits by the given amount.
    If insufficient permits are available then the current thread becomes disabled for thread scheduling purposes and lies dormant until one of three things happens:
    - Some other thread invokes one of the release methods for this semaphore, the current thread is next to be assigned permits and the number of available permits satisfies this request; or
    - Some other thread interrupts the current thread; or
    - The specified waiting time elapses.
    If the permits are acquired then the value true is returned.
    If the specified waiting time elapses then the value false is returned. If the time is less than or equal to zero, the method will not wait at all.
    
    If the ISemaphore instance is destroyed while the thread is waiting then InstanceDestroyedException will be thrown.
    If the current thread:
    - has its interrupted status set on entry to this method; or
    - is interrupted while waiting for a permit,
    then InterruptedException is thrown and the current thread's interrupted status is cleared.
    Specified by:
    
    tryAcquire in interface ISemaphore
    
    Parameters:
    permits - the number of permits to acquire
    timeout - the maximum time to wait for the permits
    unit - the time unit of the timeout argument
    
    Returns:
    true if all permits were acquired and false if the waiting time elapsed before all permits could be acquired
    
    Throws:
    
    InstanceDestroyedException - if the instance is destroyed while waiting
    
    InterruptedException - if the current thread is interrupted
  - tryAcquireAttach
```
public boolean tryAcquireAttach()
```
    Description copied from interface: ISemaphore
    
    Acquires a permit from this semaphore and attaches it to the calling member, only if one is available at the time of invocation.
    See ISemaphore.tryAcquire() and ISemaphore.attach().
    
    Specified by:
    
    tryAcquireAttach in interface ISemaphore
    
    Returns:
    true if permit was acquired and attached to the caller's address
  - tryAcquireAttach
```
public boolean tryAcquireAttach(int permits)
```
    Description copied from interface: ISemaphore
    
    Acquires the given number of permits from this semaphore and attaches them to the calling member, only if all are available at the time of invocation.
    See ISemaphore.tryAcquire(int permits) and ISemaphore.attach(int).
    
    Specified by:
    
    tryAcquireAttach in interface ISemaphore
    
    Parameters:
    permits - the number of permits to try to acquire and attach
    
    Returns:
    true if permit(s) were acquired and attached to the caller's address
  - tryAcquireAttach
```
public boolean tryAcquireAttach(long timeout,
                       TimeUnit unit)
                         throws InstanceDestroyedException,
                                InterruptedException
```
    Description copied from interface: ISemaphore
    
    Acquires a permit from this semaphore and attaches it to the calling member, only if one becomes available within the given waiting time and the current thread has not been interrupted or the instance destroyed.
    If the ISemaphore instance is destroyed while the thread is waiting then InstanceDestroyedException will be thrown.
    See ISemaphore.tryAcquire(long timeout, TimeUnit unit) and ISemaphore.attach().
    
    Specified by:
    
    tryAcquireAttach in interface ISemaphore
    
    Parameters:
    timeout - the maximum time to wait for a permit
    unit - unit the time unit of the timeout argument
    
    Returns:
    true if a permit was acquired and false if the waiting time elapsed before a permit could be acquired
    
    Throws:
    
    InstanceDestroyedException - if the instance is destroyed while waiting
    
    InterruptedException - if the current thread is interrupted
  - tryAcquireAttach
```
public boolean tryAcquireAttach(int permits,
                       long timeout,
                       TimeUnit unit)
                         throws InstanceDestroyedException,
                                InterruptedException
```
    Description copied from interface: ISemaphore
    
    Acquires the given number of permits from this semaphore and attaches them to the calling member, only if all become available within the given waiting time and the current thread has not been interrupted or the instance destroyed.
    See ISemaphore.tryAcquire(int permits, long timeout, TimeUnit unit) and ISemaphore.attach(int).
    
    Specified by:
    
    tryAcquireAttach in interface ISemaphore
    
    Parameters:
    permits - the number of permits to try to acquire and attach
    timeout - the maximum time to wait for the permits
    unit - unit the time unit of the timeout argument
    
    Returns:
    true if permit(s) were acquired and attached to the caller's address and false if the waiting time elapsed before the permits could be acquired
    
    Throws:
    
    InstanceDestroyedException - if the instance is destroyed while waiting
    
    InterruptedException - if the current thread is interrupted
  - getInstanceType
```
public Instance.InstanceType getInstanceType()
```
    Description copied from interface: Instance
    
    Returns instance type such as map, set, list, lock, topic, multimap, id generator
    
    Specified by:
    
    getInstanceType in interface Instance
    
    Returns:
    instance type
  - destroy
```
public void destroy()
```
    Description copied from interface: Instance
    
    Destroys this instance cluster-wide. Clears and releases all resources for this instance.
    
    Specified by:
    
    destroy in interface Instance
  - getId
```
public Object getId()
```
    Description copied from interface: Instance
    
    Returns the unique id for this instance.
    
    Specified by:
    
    getId in interface Instance
    
    Returns:
    id the of this instance
  - getName
```
public String getName()
```
    Description copied from interface: ISemaphore
    
    Returns the name of this ISemaphore instance.
    
    Specified by:
    
    getName in interface ISemaphore
    
    Returns:
    name of this instance
  - getLocalSemaphoreStats
```
public LocalSemaphoreStats getLocalSemaphoreStats()
```
    Specified by:
    
    getLocalSemaphoreStats in interface ISemaphore

Class SemaphoreClientProxy

Nested Class Summary

Nested classes/interfaces inherited from interface com.hazelcast.core.Instance

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

SemaphoreClientProxy

Method Detail

acquire

acquire

acquireAsync

acquireAsync

acquireAttach

acquireAttach

acquireAttachAsync

acquireAttachAsync

attach

attach

attachedPermits

availablePermits

detach

detach

drainPermits

reducePermits

release

release

releaseDetach

releaseDetach

tryAcquire

tryAcquire

tryAcquire

tryAcquire

tryAcquireAttach

tryAcquireAttach

tryAcquireAttach

tryAcquireAttach

getInstanceType

destroy

getId

getName

getLocalSemaphoreStats