#include <berryILock.h>

Inheritance diagram for berry::ILock:

Collaboration diagram for berry::ILock:

Public Member Functions
	berryObjectMacro (berry::ILock)

virtual bool	Acquire (long delay)=0 throw (InterruptedException)

virtual void	Acquire ()

virtual int	GetDepth ()=0

virtual void	Release ()=0

Public Member Functions inherited from berry::Object
virtual QString	GetClassName () const

virtual Reflection::TypeInfo	GetTypeInfo () const

virtual QList< Reflection::TypeInfo >	GetSuperclasses () const

virtual void	Delete ()

QDebug	Print (QDebug os, Indent Indent=0) const

virtual QString	ToString () const

virtual uint	HashCode () const

virtual bool	operator< (const Object *) const

void	Register () const

void	UnRegister (bool del=true) const

int	GetReferenceCount () const

void	SetReferenceCount (int)

void	AddDestroyListener (const MessageAbstractDelegate<> &delegate) const

void	RemoveDestroyListener (const MessageAbstractDelegate<> &delegate) const

virtual bool	operator== (const Object *) const

Additional Inherited Members
Public Types inherited from berry::Object
typedef Object	Self

typedef berry::SmartPointer< Self >	Pointer

typedef berry::SmartPointer< const Self >	ConstPointer

typedef berry::WeakPointer< Self >	WeakPtr

typedef berry::WeakPointer< const Self >	ConstWeakPtr

Static Public Member Functions inherited from berry::Object
static const char *	GetStaticClassName ()

static Reflection::TypeInfo	GetStaticTypeInfo ()

static QList< Reflection::TypeInfo >	GetStaticSuperclasses ()

Protected Member Functions inherited from berry::Object
	Object ()

virtual	~Object ()

virtual QDebug	PrintSelf (QDebug os, Indent indent) const

virtual QDebug	PrintHeader (QDebug os, Indent indent) const

virtual QDebug	PrintTrailer (QDebug os, Indent indent) const

Protected Attributes inherited from berry::Object
QAtomicInt	m_ReferenceCount

QMutex	m_ReferenceCountLock

Detailed Description

A lock is used to control access to an exclusive resource.

Locks are reentrant. That is, they can be acquired multiple times by the same thread without releasing. Locks are only released when the number of successful acquires equals the number of successful releases.

Locks are capable of detecting and recovering from programming errors that cause circular waiting deadlocks. When a deadlock between two or more ILock instances is detected, detailed debugging information is printed to the log file. The locks will then automatically recover from the deadlock by employing a release and wait strategy. One thread will lose control of the locks it owns, thus breaking the deadlock and allowing other threads to proceed. Once that thread's locks are all available, it will be given exclusive access to all its locks and allowed to proceed. A thread can only lose locks while it is waiting on an acquire() call.

Successive acquire attempts by different threads are queued and serviced on a first come, first served basis.

It is very important that acquired locks eventually get released. Calls to release should be done in a finally block to ensure they execute. For example:

try {
  lock.acquire();
  // ... do work here ...
} finally {
  lock.release();
}

Note: although lock.acquire should never fail, it is good practice to place it inside the try block anyway. Releasing without acquiring is far less catastrophic than acquiring without releasing.

See also: IJobManager::NewLock()

Note: This interface is not intended to be implemented by clients.

Definition at line 62 of file berryILock.h.

Member Function Documentation

◆ Acquire() [1/2]

virtual void berry::ILock::Acquire ( )

virtual

Acquires this lock. If the lock is in use, the calling thread will block until the lock becomes available. If the calling thread owns several locks, it will be blocked until all threads it requires become available, or until the thread is interrupted. While a thread is waiting, its locks may be granted to other threads if necessary to break a deadlock. On returning from this call, the calling thread will have exclusive access to this lock, and any other locks it owned upon entering the acquire method.

This implementation ignores attempts to interrupt the thread. If response to interruption is needed, use the method acquire(long)

◆ Acquire() [2/2]

virtual bool berry::ILock::Acquire	(	long	delay	)
throw	(	InterruptedException
	)

pure virtual

Attempts to acquire this lock. If the lock is in use and the specified delay is greater than zero, the calling thread will block until one of the following happens:

This lock is available
The thread is interrupted
The specified delay has elapsed

While a thread is waiting, locks it already owns may be granted to other threads if necessary to break a deadlock. In this situation, the calling thread may be blocked for longer than the specified delay. On returning from this call, the calling thread will once again have exclusive access to any other locks it owned upon entering the acquire method.

Parameters

delay the number of milliseconds to delay

Returns: true if the lock was successfully acquired, and false otherwise.

Exceptions

InterruptedException if the thread was interrupted

◆ berryObjectMacro()

berry::ILock::berryObjectMacro ( berry::ILock )

◆ GetDepth()

virtual int berry::ILock::GetDepth ( )

pure virtual

Returns the number of nested acquires on this lock that have not been released. This is the number of times that release() must be called before the lock is freed.

Returns: the number of nested acquires that have not been released

◆ Release()

virtual void berry::ILock::Release ( )

pure virtual

Releases this lock. Locks must only be released by the thread that currently owns the lock.

The documentation for this struct was generated from the following file:

berryILock.h

Public Member Functions

Additional Inherited Members

Detailed Description

Member Function Documentation

◆ Acquire() [1/2]

◆ Acquire() [2/2]

◆ berryObjectMacro()

◆ GetDepth()

◆ Release()