|
|
using System;
|
|
|
using System.Threading;
|
|
|
|
|
|
namespace Implab.Parallels {
|
|
|
/// <summary>
|
|
|
/// Implements a lightweight mechanism to aquire a shared or an exclusive lock.
|
|
|
/// </summary>
|
|
|
public class SharedLock {
|
|
|
readonly object m_lock = new object();
|
|
|
// the count of locks currently acquired by clients
|
|
|
int m_locks;
|
|
|
// the count of pending requests for upgrade
|
|
|
int m_upgrades;
|
|
|
bool m_exclusive;
|
|
|
|
|
|
public bool LockExclusive(int timeout) {
|
|
|
lock (m_lock) {
|
|
|
var dt = timeout;
|
|
|
if (m_locks > m_upgrades) {
|
|
|
var t1 = Environment.TickCount;
|
|
|
do {
|
|
|
if (!Monitor.Wait(m_lock, timeout))
|
|
|
return false;
|
|
|
|
|
|
if (m_locks == m_upgrades)
|
|
|
break;
|
|
|
|
|
|
if (timeout > 0) {
|
|
|
dt = timeout - Environment.TickCount + t1;
|
|
|
if (dt < 0)
|
|
|
return false;
|
|
|
}
|
|
|
} while(true);
|
|
|
}
|
|
|
m_exclusive = true;
|
|
|
m_locks ++;
|
|
|
return true;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
public void LockExclusive() {
|
|
|
lock (m_lock) {
|
|
|
|
|
|
while (m_locks > m_upgrades)
|
|
|
Monitor.Wait(m_lock);
|
|
|
|
|
|
m_exclusive = true;
|
|
|
m_locks ++;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// Acquires a shared lock.
|
|
|
/// </summary>
|
|
|
/// <returns><c>true</c>, if the shared lock was acquired, <c>false</c> if the specified timeout was expired.</returns>
|
|
|
/// <param name="timeout">Timeout.</param>
|
|
|
public bool LockShared(int timeout) {
|
|
|
lock (m_lock) {
|
|
|
if (!m_exclusive) {
|
|
|
m_locks++;
|
|
|
return true;
|
|
|
}
|
|
|
|
|
|
if (m_locks == m_upgrades) {
|
|
|
m_exclusive = false;
|
|
|
m_locks = 1;
|
|
|
return true;
|
|
|
}
|
|
|
|
|
|
var t1 = Environment.TickCount;
|
|
|
var dt = timeout;
|
|
|
do {
|
|
|
if (!Monitor.Wait(m_lock, dt))
|
|
|
return false;
|
|
|
|
|
|
if (m_locks == m_upgrades || !m_exclusive)
|
|
|
break;
|
|
|
|
|
|
if (timeout >= 0) {
|
|
|
dt = timeout - Environment.TickCount + t1;
|
|
|
if (dt < 0)
|
|
|
return false;
|
|
|
}
|
|
|
} while(true);
|
|
|
|
|
|
m_locks ++;
|
|
|
m_exclusive = false;
|
|
|
return true;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// Acquires the shared lock.
|
|
|
/// </summary>
|
|
|
public void LockShared() {
|
|
|
lock (m_lock) {
|
|
|
if (!m_exclusive) {
|
|
|
m_locks++;
|
|
|
} else if (m_locks == m_upgrades) {
|
|
|
m_exclusive = false;
|
|
|
m_locks++;
|
|
|
} else {
|
|
|
while (m_exclusive && m_locks > m_upgrades)
|
|
|
Monitor.Wait(m_lock);
|
|
|
|
|
|
m_locks++;
|
|
|
m_exclusive = false;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// Upgrades the current lock to exclusive level.
|
|
|
/// </summary>
|
|
|
/// <remarks>If the current lock is exclusive already the method does nothing.</remarks>
|
|
|
public void Upgrade() {
|
|
|
lock (m_lock) {
|
|
|
if (!m_exclusive) {
|
|
|
|
|
|
if (m_locks <= m_upgrades)
|
|
|
throw new InvalidOperationException();
|
|
|
|
|
|
if (m_locks - m_upgrades == 1) {
|
|
|
m_exclusive = true;
|
|
|
} else {
|
|
|
m_upgrades++;
|
|
|
|
|
|
while (m_locks > m_upgrades)
|
|
|
Monitor.Wait(m_lock);
|
|
|
|
|
|
m_upgrades--;
|
|
|
m_exclusive = true;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// Upgrades the current lock to exclusive level.
|
|
|
/// </summary>
|
|
|
/// <param name="timeout">Timeout.</param>
|
|
|
/// <returns><c>true</c> if the current lock was updated, <c>false</c> the specified timeout was expired.</returns>
|
|
|
/// <remarks>If the current lock is exclusive already the method does nothing.</remarks>
|
|
|
public bool Upgrade(int timeout) {
|
|
|
lock (m_lock) {
|
|
|
if (m_exclusive)
|
|
|
return true;
|
|
|
if (m_locks <= m_upgrades)
|
|
|
throw new InvalidOperationException();
|
|
|
|
|
|
if (m_locks - m_upgrades == 1) {
|
|
|
m_exclusive = true;
|
|
|
} else {
|
|
|
var t1 = Environment.TickCount;
|
|
|
var dt = timeout;
|
|
|
m_upgrades++;
|
|
|
do {
|
|
|
if (!Monitor.Wait(m_lock, dt)) {
|
|
|
m_upgrades--;
|
|
|
return false;
|
|
|
}
|
|
|
|
|
|
// we may get there but the shared lock already aquired
|
|
|
if (m_locks == m_upgrades)
|
|
|
break;
|
|
|
|
|
|
if (timeout >= 0) {
|
|
|
dt = timeout - Environment.TickCount + t1;
|
|
|
if (dt < 0) {
|
|
|
m_upgrades--;
|
|
|
return false;
|
|
|
}
|
|
|
}
|
|
|
} while(true);
|
|
|
m_upgrades--;
|
|
|
m_exclusive = true;
|
|
|
}
|
|
|
return true;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// Downgrades this lock to shared level.
|
|
|
/// </summary>
|
|
|
public void Downgrade() {
|
|
|
lock (m_lock)
|
|
|
m_exclusive = false;
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// Releases the current lock.
|
|
|
/// </summary>
|
|
|
public void Release() {
|
|
|
lock (m_lock)
|
|
|
// if no more running threads left
|
|
|
if (--m_locks == m_upgrades)
|
|
|
Monitor.PulseAll(m_lock);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
|
