Uses of Interface org.ematgine.utils.concurrent.Sync

Overview

Package

Class

Use

Deprecated

Index

Home >> All >> org >> ematgine >> utils >> [ concurrent overview ]

PREV NEXT

Uses of Interface
org.ematgine.utils.concurrent.Sync

Uses of Sync in org.ematgine.utils.concurrent

Classes in org.ematgine.utils.concurrent that implement Sync

class CountDown
          A CountDown can serve as a simple one-shot barrier.

(package private) class FIFOReadWriteLock.ReaderSync


class FIFOSemaphore
          A First-in/First-out implementation of a Semaphore.

class Latch
          A latch is a boolean condition that is set at most once, ever.

class LayeredSync
          A class that can be used to compose Syncs.

class Mutex
          A simple non-reentrant mutual exclusion lock.

class NullSync
          A No-Op implementation of Sync.

class ObservableSync
          The ObservableSync class performs no synchronization itself, but invokes event-style messages to other observer objects upon invocation of Sync methods.

class PrioritySemaphore
          A Semaphore that grants requests to threads with higher Thread priority rather than lower priority when there is contention.

class QueuedSemaphore
          Abstract base class for semaphores relying on queued wait nodes

class ReentrantLock
          A lock with the same semantics as builtin Java synchronized locks: Once a thread has a lock, it can re-obtain it any number of times without blocking.

class Semaphore
          Base class for counting semaphores.

class TimeoutSync
          A TimeoutSync is an adaptor class that transforms all calls to acquire to instead invoke attempt with a predetermined timeout value.

class WaiterPreferenceSemaphore
          An implementation of counting Semaphores that enforces enough fairness for applications that need to avoid indefinite overtaking without necessarily requiring FIFO ordered access.

protected class WriterPreferenceReadWriteLock.ReaderLock


protected class WriterPreferenceReadWriteLock.WriterLock

Fields in org.ematgine.utils.concurrent declared as Sync

protected Sync TimeoutSync.sync_


protected Sync SyncMap.rd_


protected Sync SyncMap.wr_


protected Sync SyncCollection.rd_


protected Sync SyncCollection.wr_


protected Sync LockedExecutor.mutex_
          The mutex

protected Sync LayeredSync.outer_


protected Sync LayeredSync.inner_


protected Sync FIFOReadWriteLock.readerSync_
          Control reader access to active semaphore

protected Sync CondVar.mutex_
          The mutex

Methods in org.ematgine.utils.concurrent that return Sync

Sync WriterPreferenceReadWriteLock.writeLock()


Sync WriterPreferenceReadWriteLock.readLock()


Sync SyncMap.readerSync()
          Return the Sync object managing read-only operations

Sync SyncMap.writerSync()
          Return the Sync object managing mutative operations

Sync SyncCollection.readerSync()
          Return the Sync object managing read-only operations

Sync SyncCollection.writerSync()
          Return the Sync object managing mutative operations

Sync ReadWriteLock.readLock()
          get the readLock

Sync ReadWriteLock.writeLock()
          get the writeLock

Sync FIFOReadWriteLock.writeLock()


Sync FIFOReadWriteLock.readLock()

Constructors in org.ematgine.utils.concurrent with parameters of type Sync

TimeoutSync(Sync sync, long timeout)
          Create a TimeoutSync using the given Sync object, and using the given timeout value for all calls to acquire.

SyncSortedSet(java.util.SortedSet set, Sync sync)
          Create a new SyncSortedSet protecting the given collection, and using the given sync to control both reader and writer methods.

SyncSortedSet(java.util.SortedSet set, Sync readLock, Sync writeLock)
          Create a new SyncSortedSet protecting the given set, and using the given pair of locks to control reader and writer methods.

SyncSortedMap(java.util.SortedMap map, Sync sync)
          Create a new SyncSortedMap protecting the given map, and using the given sync to control both reader and writer methods.

SyncSortedMap(java.util.SortedMap map, Sync readLock, Sync writeLock)
          Create a new SyncSortedMap protecting the given map, and using the given pair of locks to control reader and writer methods.

SyncSet(java.util.Set set, Sync sync)
          Create a new SyncSet protecting the given collection, and using the given sync to control both reader and writer methods.

SyncSet(java.util.Set set, Sync readLock, Sync writeLock)
          Create a new SyncSet protecting the given set, and using the given pair of locks to control reader and writer methods.

SyncMap(java.util.Map map, Sync sync)
          Create a new SyncMap protecting the given map, and using the given sync to control both reader and writer methods.

SyncMap(java.util.Map map, Sync readLock, Sync writeLock)
          Create a new SyncMap protecting the given map, and using the given pair of locks to control reader and writer methods.

SyncList(java.util.List list, Sync sync)
          Create a new SyncList protecting the given collection, and using the given sync to control both reader and writer methods.

SyncList(java.util.List list, Sync readLock, Sync writeLock)
          Create a new SyncList protecting the given list, and using the given pair of locks to control reader and writer methods.

SyncCollection(java.util.Collection collection, Sync sync)
          Create a new SyncCollection protecting the given collection, and using the given sync to control both reader and writer methods.

SyncCollection(java.util.Collection collection, Sync readLock, Sync writeLock)
          Create a new SyncCollection protecting the given collection, and using the given pair of locks to control reader and writer methods.

LockedExecutor(Sync mutex)
          Create a new LockedExecutor that relies on the given mutual exclusion lock.

LayeredSync(Sync outer, Sync inner)
          Create a LayeredSync managing the given outer and inner Sync objects

CondVar(Sync mutex)
          Create a new CondVar that relies on the given mutual exclusion lock.