locklib.sx

Class SxLockPolicy

java.lang.Object

locklib.sx.SxLockPolicy

All Implemented Interfaces:

LockPolicy<SxLockType>

public class SxLockPolicy
extends Object
implements LockPolicy<SxLockType>

Locking policy for SX locking. In an SX locking policy, locking a child requires share-locking its parent.

Constructor Summary

Constructors

Constructor and Description
SxLockPolicy(boolean starvation_allowed) Creates a new SX locking policy.

Method Summary

Modifier and Type	Method and Description
boolean	is_compatible(SxLockType lock_type_1, SxLockType lock_type_2) Checks if two locks are compatible.
SxLockType	parent_lock(SxLockType 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

SxLockPolicy

public SxLockPolicy(boolean starvation_allowed)

Creates a new SX locking policy.

Parameters:

starvation_allowed - is starvation allowed? (see LockPolicy.starvation_allowed())

Method Detail

is_compatible

public boolean is_compatible(SxLockType lock_type_1,
                             SxLockType 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<SxLockType>

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 SxLockType parent_lock(SxLockType 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<SxLockType>

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

Returns:

is starvation allowed