Overview | Package | Class | Tree | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## de.grogra.util
Class LockableImpl

    java.lang.Object
      de.grogra.util.LockableImpl

All Implemented Interfaces:
  Lockable

Direct Known Subclasses:
  PersistenceManager

    public class LockableImpl

extends java.lang.Object
implements Lockable

Nested Class Summary

Nested classes/interfaces inherited from interface de.grogra.util.Lockable
`Lockable.DeadLockException`

Constructor Summary
`LockableImpl()`

Method Summary
`protected void` | `enterWriteLock()`
`void` | `execute(LockProtectedRunnable task, boolean write)` Asynchronously executes a `task` such that it possesses a lock on this `Lockable`.
`void` | `execute(LockProtectedRunnable task, Lock retained)` Asynchronously executes a `task` using a lock which has been retained before within another task.
`void` | `executeForcedly(LockProtectedRunnable task, boolean write)` Synchronously executes a `task` such that it possesses a lock on this `Lockable`.
`void` | `executeForcedly(LockProtectedRunnable task, Lock retained)` Synchronously executes a `task` using a lock which has been retained before within another task.
`protected void` | `executeInAllowedThread(java.lang.Runnable r)`
`long` | `getMaxWaitingTime()` Returns the waiting time of the pending task which is waiting longest, or `-1` if there is no pending task.
`int` | `getQueueLength()` Returns the current number of tasks which are waiting for locked execution.
`protected void` | `invokeRun(LockProtectedRunnable task, boolean sync, Lock lock)`
`protected boolean` | `isAllowedThread(boolean write)`
`boolean` | `isLocked(boolean write)` Determines if the current thread has a lock for this `Lockable`.
`protected void` | `leaveWriteLock()`

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

Constructor Detail

### LockableImpl

    public LockableImpl()

Method Detail

### enterWriteLock

    protected void enterWriteLock()

### execute

    public void execute(LockProtectedRunnable task,
                        boolean write)

  Description copied from interface: `Lockable`
  Asynchronously executes a `task` such that it possesses a lock on this `Lockable`. Note that the execution is asynchronous, so that the thread in which the task will actually be executed may differ from the current thread.

  Specified by:
    `execute` in interface `Lockable`
  Parameters:
    `task` - the task to execute
    `write` - shall a write lock be obtained?

### execute

    public void execute(LockProtectedRunnable task,
                        Lock retained)

  Description copied from interface: `Lockable`
  Asynchronously executes a `task` using a lock which has been retained before within another task. Note that the execution is asynchronous, so that the thread in which the task will actually be executed may differ from the current thread.

  Specified by:
    `execute` in interface `Lockable`
  Parameters:
    `task` - the task to execute
    `retained` - the previously retained lock
  See Also:
    `Lock.retain()`

### executeForcedly

    public void executeForcedly(LockProtectedRunnable task,
                                boolean write)
                         throws java.lang.InterruptedException,
                                Lockable.DeadLockException

  Description copied from interface: `Lockable`
  Synchronously executes a `task` such that it possesses a lock on this `Lockable`. The execution is performed in the current thread.

  Specified by:
    `executeForcedly` in interface `Lockable`
  Parameters:
    `task` - the task to execute
    `write` - shall a write lock be obtained?
  Throws:
    `java.lang.InterruptedException`
    `Lockable.DeadLockException`

### executeForcedly

    public void executeForcedly(LockProtectedRunnable task,
                                Lock retained)
                         throws java.lang.InterruptedException

  Description copied from interface: `Lockable`
  Synchronously executes a `task` using a lock which has been retained before within another task. The execution is performed in the current thread.

  Specified by:
    `executeForcedly` in interface `Lockable`
  Parameters:
    `task` - the task to execute
    `retained` - the previously retained lock
  Throws:
    `java.lang.InterruptedException`
  See Also:
    `Lock.retain()`

### executeInAllowedThread

    protected void executeInAllowedThread(java.lang.Runnable r)

### getMaxWaitingTime

    public long getMaxWaitingTime()

  Description copied from interface: `Lockable`
  Returns the waiting time of the pending task which is waiting longest, or `-1` if there is no pending task.

  Specified by:
    `getMaxWaitingTime` in interface `Lockable`
  Returns:
    current maximum waiting time of pending tasks

### getQueueLength

    public int getQueueLength()

  Description copied from interface: `Lockable`
  Returns the current number of tasks which are waiting for locked execution.

  Specified by:
    `getQueueLength` in interface `Lockable`
  Returns:
    current number of waiting tasks

### invokeRun

    protected void invokeRun(LockProtectedRunnable task,
                             boolean sync,
                             Lock lock)

### isAllowedThread

    protected boolean isAllowedThread(boolean write)

### isLocked

    public boolean isLocked(boolean write)

  Description copied from interface: `Lockable`
  Determines if the current thread has a lock for this `Lockable`.

  Specified by:
    `isLocked` in interface `Lockable`
  Parameters:
    `write` - check for write locks only (`true`) or for both read and write locks (`false`)
  Returns:
    `true` if the current thread has a lock

### leaveWriteLock

    protected void leaveWriteLock()

Overview | Package | Class | Tree | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD