locklib.mutex

Class MutexLockPolicy

java.lang.Object

locklib.mutex.MutexLockPolicy

All Implemented Interfaces:

LockPolicy<MutexLockType>

public class MutexLockPolicy
extends Object
implements LockPolicy<MutexLockType>

Locking policy for mutex locking. In a mutex locking policy, locking a child requires locking its parent.

Constructor Summary

Constructors

Constructor and Description
MutexLockPolicy() Creates a new mutex locking policy.

Method Summary

Modifier and Type	Method and Description
boolean	is_compatible(MutexLockType lock_type_1, MutexLockType lock_type_2) Checks if two locks are compatible.
MutexLockType	parent_lock(MutexLockType lock_type) Determines what is the type of lock a parent of a target should have.
boolean	starvation_allowed() If starvation is allowed compatible locks can be acquired even if there are locks waiting.

Methods inherited from class java.lang.Object

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

Constructor Detail

MutexLockPolicy

public MutexLockPolicy()

Creates a new mutex locking policy.

Method Detail

is_compatible

public boolean is_compatible(MutexLockType lock_type_1,
                             MutexLockType lock_type_2)

Description copied from interface: LockPolicy

Checks if two locks are compatible. Two locks are compatible if different holders can hold them in the same target.

Specified by:

is_compatible in interface LockPolicy<MutexLockType>

Parameters:

lock_type_1 - the type of lock of one holder

lock_type_2 - the type of lock of another holder

Returns:

are both locks compatible?

parent_lock

public MutexLockType parent_lock(MutexLockType lock_type)

Description copied from interface: LockPolicy

Determines what is the type of lock a parent of a target should have.

Specified by:

parent_lock in interface LockPolicy<MutexLockType>

Parameters:

lock_type - the type of lock held by the target

Returns:

the type of lock that a parent should hold if its child has lock lock_type; this must not return null as the parent must have some lock type to generate the lock chain

starvation_allowed

public boolean starvation_allowed()

Description copied from interface: LockPolicy

If starvation is allowed compatible locks can be acquired even if there are locks waiting. For example, in SX locks, it means a S lock can be acquired for a target when there is an X lock waiting. This means that the X lock can be held forever if S locks keep coming and going. If starvation is not allowed, then, in the previous example, an S lock is disallowed if there is an X lock waiting, even if the S lock is compatible with the currently-held lock. Whether starvation is allowed or not is irrelevant for lock types that are always exclusive.

Specified by:

starvation_allowed in interface LockPolicy<MutexLockType>

Returns:

is starvation allowed