Package org.apache.ignite.internal.processors.datastructures

Class GridCacheSemaphoreImpl

java.lang.Object

org.apache.ignite.internal.processors.datastructures.AtomicDataStructureProxy<GridCacheSemaphoreState>

org.apache.ignite.internal.processors.datastructures.GridCacheSemaphoreImpl

All Implemented Interfaces:

Closeable, Externalizable, Serializable, AutoCloseable, IgniteSemaphore, IgniteChangeGlobalStateSupport, GridCacheRemovable, GridCacheSemaphoreEx

public final class GridCacheSemaphoreImpl
extends AtomicDataStructureProxy<GridCacheSemaphoreState>
implements GridCacheSemaphoreEx, IgniteChangeGlobalStateSupport, Externalizable

Cache semaphore implementation based on AbstractQueuedSynchronizer. Current implementation supports only unfair semaphores. If any node fails after acquiring permissions on cache semaphore, there are two different behaviors controlled with the parameter failoverSafe. If this parameter is true, other nodes can reacquire permits that were acquired by the failing node. In case this parameter is false, IgniteInterruptedException is called on every node waiting on this semaphore.

See Also:

Serialized Form

Field Summary

Fields inherited from class org.apache.ignite.internal.processors.datastructures.AtomicDataStructureProxy

cacheView, ctx, key, log, name, rmvd

Constructor Summary

Constructors

Constructor	Description
GridCacheSemaphoreImpl()	Empty constructor required by Externalizable.
GridCacheSemaphoreImpl(String name, GridCacheInternalKey key, IgniteInternalCache<GridCacheInternalKey,GridCacheSemaphoreState> semView)	Constructor.

Method Summary

Modifier and Type	Method	Description
void	acquire()	Acquires a permit from this semaphore, blocking until one is available, or the thread is interrupted.
void	acquire(int permits)	Acquires the given number of permits from this semaphore, blocking until all are available, or the thread is interrupted.
<T> IgniteFuture<T>	acquireAndExecute(IgniteCallable<T> callable, int numPermits)	Acquires the given semaphore, executes the given callable and schedules the release of permits asynchronously
void	acquireUninterruptibly()	Acquires a permit from this semaphore, blocking until one is available.
void	acquireUninterruptibly(int permits)	Acquires the given number of permits from this semaphore, blocking until all are available.
int	availablePermits()	Returns the current number of permits available in this semaphore.
void	close()	Removes this semaphore.
int	drainPermits()	Acquires and returns all permits that are immediately available.
int	getQueueLength()	Returns an estimate of the number of nodes waiting to acquire.
boolean	hasQueuedThreads()	Queries whether any threads are waiting to acquire.
boolean	isBroken()	Gets broken status of the semaphore.
boolean	isFailoverSafe()	Returns true if this semaphore is safe to use after node failure.
void	needCheckNotRemoved()
void	onNodeRemoved(UUID nodeId)	Callback to notify semaphore on topology changes.
void	onUpdate(GridCacheSemaphoreState val)	Callback to notify semaphore on changes.
void	readExternal(ObjectInput in)
void	release()	Releases a permit, returning it to the semaphore.
void	release(int permits)	Releases the given number of permits, returning them to the semaphore.
void	stop()	Callback to notify local semaphore instance on node stop.
String	toString()
boolean	tryAcquire()	Acquires a permit from this semaphore, only if one is available at the time of invocation.
boolean	tryAcquire(int permits)	Acquires the given number of permits from this semaphore, only if all are available at the time of invocation.
boolean	tryAcquire(int permits, long timeout, TimeUnit unit)	Acquires the given number of permits from this semaphore, if all become available within the given waiting time and the current thread has not been interrupted.
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.
void	writeExternal(ObjectOutput out)

Methods inherited from class org.apache.ignite.internal.processors.datastructures.AtomicDataStructureProxy

checkRemoved, checkRemovedAfterFail, invalidateLocalState, key, name, onActivate, onDeActivate, onRemoved, removed, restart, suspend

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Methods inherited from interface org.apache.ignite.internal.processors.datastructures.GridCacheRemovable

onRemoved, restart, suspend

Methods inherited from interface org.apache.ignite.internal.processors.datastructures.GridCacheSemaphoreEx

key

Methods inherited from interface org.apache.ignite.internal.processors.cluster.IgniteChangeGlobalStateSupport

onActivate, onDeActivate

Methods inherited from interface org.apache.ignite.IgniteSemaphore

name, removed

Constructor Detail

GridCacheSemaphoreImpl

public GridCacheSemaphoreImpl()

Empty constructor required by Externalizable.

GridCacheSemaphoreImpl

public GridCacheSemaphoreImpl(String name,
                              GridCacheInternalKey key,
                              IgniteInternalCache<GridCacheInternalKey,GridCacheSemaphoreState> semView)

Constructor.

Parameters:

name - Semaphore name.

key - Semaphore key.

semView - Semaphore projection.

Method Detail

onUpdate

public void onUpdate(GridCacheSemaphoreState val)

Callback to notify semaphore on changes.

Specified by:

onUpdate in interface GridCacheSemaphoreEx

Parameters:

val - State containing the number of available permissions.

onNodeRemoved

public void onNodeRemoved(UUID nodeId)

Callback to notify semaphore on topology changes.

Specified by:

onNodeRemoved in interface GridCacheSemaphoreEx

Parameters:

nodeId - Id of the node that left the grid.

stop

public void stop()

Callback to notify local semaphore instance on node stop.

Specified by:

stop in interface GridCacheSemaphoreEx

needCheckNotRemoved

public void needCheckNotRemoved()

Specified by:

needCheckNotRemoved in interface GridCacheRemovable

Overrides:

needCheckNotRemoved in class AtomicDataStructureProxy<GridCacheSemaphoreState>

acquire

public void acquire()
             throws IgniteInterruptedException

Acquires a permit from this semaphore, blocking until one is available, or the thread is interrupted.

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 two things happens:

• Some other thread invokes the IgniteSemaphore.release() method for this semaphore and the current thread is next to be assigned a permit; or
• Some other thread interrupts the current thread.

If the current thread:

• has its interrupted status set on entry to this method; or
• is interrupted while waiting for a permit,

then IgniteInterruptedException is thrown and the current thread's interrupted status is cleared.

Specified by:

acquire in interface IgniteSemaphore

Throws:

IgniteInterruptedException - if the current thread is interrupted

acquire

public void acquire(int permits)
             throws IgniteInterruptedException

Acquires the given number of permits from this semaphore, blocking until all are available, or the thread is interrupted.

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 two 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.

If the current thread:

• has its interrupted status set on entry to this method; or
• is interrupted while waiting for a permit,

then IgniteInterruptedException is thrown and the current thread's interrupted status is cleared. Any permits that were to be assigned to this thread are instead assigned to other threads trying to acquire permits, as if permits had been made available by a call to IgniteSemaphore.release().

Specified by:

acquire in interface IgniteSemaphore

Parameters:

permits - the number of permits to acquire

Throws:

IgniteInterruptedException - if the current thread is interrupted

acquireUninterruptibly

public void acquireUninterruptibly()

Acquires a permit from this semaphore, blocking until one is available.

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 some other thread invokes the IgniteSemaphore.release() method for this semaphore and the current thread is next to be assigned a permit.

If the current thread is interrupted while waiting for a permit then it will continue to wait, but the time at which the thread is assigned a permit may change compared to the time it would have received the permit had no interruption occurred. When the thread does return from this method its interrupt status will be set.

Specified by:

acquireUninterruptibly in interface IgniteSemaphore

acquireUninterruptibly

public void acquireUninterruptibly(int permits)

Acquires the given number of permits from this semaphore, blocking until all are available.

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 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.

If the current thread is interrupted while waiting for permits then it will continue to wait and its position in the queue is not affected. When the thread does return from this method its interrupt status will be set.

Specified by:

acquireUninterruptibly in interface IgniteSemaphore

Parameters:

permits - the number of permits to acquire

acquireAndExecute

public <T> IgniteFuture<T> acquireAndExecute(IgniteCallable<T> callable,
                                             int numPermits)

Acquires the given semaphore, executes the given callable and schedules the release of permits asynchronously

Specified by:

acquireAndExecute in interface IgniteSemaphore

Type Parameters:

T - Type of the callable execution result.

Parameters:

callable - the callable to execute

numPermits - the number of permits to acquire

Returns:

Callable execution future.

availablePermits

public int availablePermits()

Returns the current number of permits available in this semaphore.

This method is typically used for debugging and testing purposes.

Specified by:

availablePermits in interface IgniteSemaphore

Returns:

the number of permits available in this semaphore

drainPermits

public int drainPermits()

Acquires and returns all permits that are immediately available.

Specified by:

drainPermits in interface IgniteSemaphore

Returns:

the number of permits acquired

tryAcquire

public boolean tryAcquire()

Acquires a permit from this semaphore, only if one is available at the time of invocation.

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 IgniteSemaphore

Returns:

true if a permit was acquired and false otherwise

tryAcquire

public boolean tryAcquire(long timeout,
                          TimeUnit unit)
                   throws IgniteException

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 IgniteSemaphore.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 current thread:

• has its interrupted status set on entry to this method; or
• is interrupted while waiting to acquire a permit,

then IgniteInterruptedException is thrown and the current thread's interrupted status is cleared.

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.

Specified by:

tryAcquire in interface IgniteSemaphore

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:

IgniteInterruptedException - if the current thread is interrupted

IgniteException

release

public void release()

Releases a permit, returning it to the semaphore.

Releases a permit, increasing the number of available permits by one. If any threads are trying to acquire a permit, then one is selected and given the permit that was just released. That thread is (re)enabled for thread scheduling purposes.

There is no requirement that a thread that releases a permit must have acquired that permit by calling IgniteSemaphore.acquire(). Correct usage of a semaphore is established by programming convention in the application.

Specified by:

release in interface IgniteSemaphore

release

public void release(int permits)

Releases the given number of permits, returning them to the semaphore.

Releases the given number of permits, increasing the number of available permits by that amount. If any threads are trying to acquire permits, then one is selected and given the permits that were just released. If the number of available permits satisfies that thread's request then that thread is (re)enabled for thread scheduling purposes; otherwise the thread will wait until sufficient permits are available. If there are still permits available after this thread's request has been satisfied, then those permits are assigned in turn to other threads trying to acquire permits.

There is no requirement that a thread that releases a permit must have acquired that permit by calling acquire. Correct usage of a semaphore is established by programming convention in the application.

Specified by:

release in interface IgniteSemaphore

Parameters:

permits - the number of permits to release

tryAcquire

public boolean tryAcquire(int permits)

Acquires the given number of permits from this semaphore, only if all are available at the time of invocation.

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.

If you want to honor the failoverSafe setting, then use tryAcquire(permits, 0, TimeUnit.SECONDS) which is almost equivalent (it also detects interruption).

Specified by:

tryAcquire in interface IgniteSemaphore

Parameters:

permits - the number of permits to acquire

Returns:

true if the permits were acquired and false otherwise

tryAcquire

public boolean tryAcquire(int permits,
                          long timeout,
                          TimeUnit unit)
                   throws IgniteInterruptedException

Acquires the given number of permits from this semaphore, if all become available within the given waiting time and the current thread has not been interrupted.

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 current thread:

• has its interrupted status set on entry to this method; or
• is interrupted while waiting to acquire the permits,

then IgniteInterruptedException is thrown and the current thread's interrupted status is cleared. Any permits that were to be assigned to this thread, are instead assigned to other threads trying to acquire permits, as if the permits had been made available by a call to IgniteSemaphore.release().

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. Any permits that were to be assigned to this thread, are instead assigned to other threads trying to acquire permits, as if the permits had been made available by a call to IgniteSemaphore.release().

Specified by:

tryAcquire in interface IgniteSemaphore

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 were acquired

Throws:

IgniteInterruptedException - if the current thread is interrupted

isFailoverSafe

public boolean isFailoverSafe()

Returns true if this semaphore is safe to use after node failure. If not, IgniteInterruptedException is thrown on every other node after node failure.

Specified by:

isFailoverSafe in interface IgniteSemaphore

Returns:

true if this semaphore has failoverSafe set true

hasQueuedThreads

public boolean hasQueuedThreads()

Queries whether any threads are waiting to acquire. Note that because cancellations may occur at any time, a true return does not guarantee that any other thread will ever acquire. This method is designed primarily for use in monitoring of the system state.

Specified by:

hasQueuedThreads in interface IgniteSemaphore

Returns:

true if there may be other threads waiting to acquire the lock

getQueueLength

public int getQueueLength()

Returns an estimate of the number of nodes waiting to acquire. The value is only an estimate because the number of nodes that are waiting may change dynamically while this method traverses internal data structures. This method is designed for use in monitoring of the system state, not for synchronization control.

Specified by:

getQueueLength in interface IgniteSemaphore

Returns:

the estimated number of nodes waiting for this lock

isBroken

public boolean isBroken()

Gets broken status of the semaphore.

Specified by:

isBroken in interface IgniteSemaphore

Returns:

True if a node failed on this semaphore and failoverSafe flag was set to false, false otherwise.

writeExternal

public void writeExternal(ObjectOutput out)
                   throws IOException

Specified by:

writeExternal in interface Externalizable

Throws:

IOException

readExternal

public void readExternal(ObjectInput in)
                  throws IOException,
                         ClassNotFoundException

Specified by:

readExternal in interface Externalizable

Throws:

IOException

ClassNotFoundException

close

public void close()

Removes this semaphore.

Specified by:

close in interface AutoCloseable

Specified by:

close in interface Closeable

Specified by:

close in interface IgniteSemaphore

toString

public String toString()

Overrides:

toString in class Object