/// <summary>
/// Adds an event handler to the list
/// </summary>
/// <param name="e">The event from which we add a handler</param>
/// <param name="del">The callback method</param>
public void AddHandler(RoadEvent e, RoadEventHandler del)
{
try
{
m_lock.AcquireWriterLock(TIMEOUT);
try
{
WeakMulticastDelegate deleg = (WeakMulticastDelegate)m_events[e];
if (deleg == null)
{
m_events[e] = new WeakMulticastDelegate(del);
}
else
{
m_events[e] = WeakMulticastDelegate.Combine(deleg, del);
}
}
finally
{
m_lock.ReleaseWriterLock();
}
}
catch (ApplicationException ex)
{
if (log.IsErrorEnabled)
{
log.Error("Failed to add event handler!", ex);
}
}
}
/// <summary>
/// Registers an edge with this vertex' local mappings. This operation is thread-safe.
/// </summary>
/// <param name="e">The Edge to register</param>
internal void RegisterEdge(Edge e)
{
_rwl.AcquireWriterLock(-1);
// undirected edges are added to the _undirectedEdges map
if (e.EdgeType == EdgeType.Undirected)
{
Vertex neighbor = (e.Source == this) ? e.Target : e.Source;
_predecessors.Add(neighbor.ID, neighbor);
_predecessorToEdgeMap.Add(neighbor.ID, e);
_successors.Add(neighbor.ID, neighbor);
_successorToEdgeMap.Add(neighbor.ID, e);
_undirectedEdges.Add(e.ID, e);
}
else if (e.EdgeType == EdgeType.DirectedAB)
{
if (e.A == this)
{
_successors.Add(e.B.ID, e.B);
_successorToEdgeMap.Add(e.B.ID, e);
_outgoingEdges.Add(e.ID, e);
}
else if (e.B == this)
{
_predecessors.Add(e.A.ID, e.A);
_predecessorToEdgeMap.Add(e.A.ID, e);
_incomingEdges.Add(e.ID, e);
}
}
else if (e.EdgeType == EdgeType.DirectedBA)
{
if (e.B == this)
{
_successors.Add(e.A.ID, e.A);
_successorToEdgeMap.Add(e.A.ID, e);
_outgoingEdges.Add(e.ID, e);
}
else if (e.A == this)
{
_predecessors.Add(e.B.ID, e.B);
_predecessorToEdgeMap.Add(e.B.ID, e);
_incomingEdges.Add(e.ID, e);
}
}
_rwl.ReleaseWriterLock();
}
public void Write(Action <T> writeMethod)
{
readerWriterLock.AcquireWriterLock(int.MaxValue);
try
{
writeMethod(data);
if (path != null)
{
File.WriteAllText(path, SerializeObject(data, Newtonsoft.Json.Formatting.Indented));
}
}
finally { readerWriterLock.ReleaseWriterLock(); }
}
public override PreviousPayment this[int i]
{
get
{
PreviousPayment thisItem;
rwLock.AcquireReaderLock(timeout);
try
{
thisItem = collection[i];
}
finally
{
rwLock.ReleaseReaderLock();
}
return(thisItem);
}
set
{
rwLock.AcquireWriterLock(timeout);
try
{
collection[i] = value;
}
finally
{
rwLock.ReleaseWriterLock();
}
}
}
public override Property this[int i]
{
get
{
Property thisItem;
_rwLock.AcquireReaderLock(Timeout);
try
{
thisItem = _collection[i];
}
finally
{
_rwLock.ReleaseReaderLock();
}
return(thisItem);
}
set
{
_rwLock.AcquireWriterLock(Timeout);
try
{
_collection[i] = value;
}
finally
{
_rwLock.ReleaseWriterLock();
}
}
}
public override eServiceCategory this[int i]
{
get
{
eServiceCategory thisItem;
rwLock.AcquireReaderLock(timeout);
try
{
thisItem = collection[i];
}
finally
{
rwLock.ReleaseReaderLock();
}
return(thisItem);
}
set
{
rwLock.AcquireWriterLock(timeout);
try
{
collection[i] = value;
}
finally
{
rwLock.ReleaseWriterLock();
}
}
}
public override StatementPhoneNumber this[int i]
{
get
{
StatementPhoneNumber thisItem;
rwLock.AcquireReaderLock(timeout);
try
{
thisItem = collection[i];
}
finally
{
rwLock.ReleaseReaderLock();
}
return(thisItem);
}
set
{
rwLock.AcquireWriterLock(timeout);
try
{
collection[i] = value;
}
finally
{
rwLock.ReleaseWriterLock();
}
}
}
private void cleaner_Elapsed(object sender, ElapsedEventArgs e)
{
var timeToClean = DateTime.Now.AddMinutes(-5);
try
{
rwlock.AcquireWriterLock(lockingTimeout);
while (codes.Count > 0 && codes.Peek().UseDate < timeToClean)
{
codes.Dequeue();
}
}
finally
{
rwlock.ReleaseWriterLock();
}
}
public void Set(string key, string value)
{
l.Debug("Set(" + key + " ," + value + ");");
Lock.AcquireWriterLock(1000);
try
{
if (settings.ContainsKey(key))
{
settings[key] = value;
}
else
{
settings.Add(key, value);
}
Save();
}
finally
{
Lock.ReleaseWriterLock();
}
}
public Lock(System.Threading.ReaderWriterLock rwl, LockType lt)
{
rwlock = rwl;
if (type == LockType.ForReading)
{
rwl.AcquireReaderLock(-1);
}
else if (type == LockType.ForWriting)
{
rwl.AcquireWriterLock(-1);
}
}
public new Add(LoadedJockey j)
{
try
{
_rw_lock.AcquireWriterLock(5000); // or whatever you deem an acceptable timeout
base.Add(j);
}
finally
{
_rw_lock.ReleaseWriterLock();
}
}
/// <summary>
/// 移除键值对
/// </summary>
public void Clear()
{
if (dictionary.Count > 0)
{
rwLock.AcquireWriterLock(lockTimeOut);
try
{
dictionary.Clear();
}
finally
{
rwLock.ReleaseWriterLock();
}
}
}
public Lock(System.Threading.ReaderWriterLock rwl, LockType lt)
{
rwlock = rwl;
if (type == LockType.ForReading)
{
rwl.AcquireReaderLock(-1);
}
else if (type == LockType.ForWriting)
{
rwl.AcquireWriterLock(-1);
}
#if DEBUG
callingfunction = new System.Diagnostics.StackTrace();
#endif
}
/// <summary>
/// Constructor
/// </summary>
public WriteLock(System.Threading.ReaderWriterLock lk, System.TimeSpan timeout)
{
_lock = lk;
if (null == _lock)
{
throw new System.ArgumentNullException("Error 2719124605: Null lock given");
}
try
{
// If this thread holds a read-lock then it has to release it before
// getting the write-lock. Otherwise, the attempt to acquire the
// write-lock below will block.
if (true == _lock.IsReaderLockHeld)
{
throw new System.Exception("Error 3637580726: Reader-lock is already held");
}
_lock.AcquireWriterLock(timeout);
}
catch (System.ApplicationException e)
{
System.Console.WriteLine("Error 3725156970: Failed to obtain lock for writing. {0}", e.Message);
throw;
}
}
private void ProcessStorage()
{
try
{
obj_rwl.AcquireWriterLock(System.Threading.Timeout.Infinite);
//在对象集合中寻找
List <CCacheItem_WuQi <K, T> > result = new List <CCacheItem_WuQi <K, T> >();
foreach (KeyValuePair <K, CCacheItem_WuQi <K, T> > defront in obj_containers)
{
CCacheItem_WuQi <K, T> item = (CCacheItem_WuQi <K, T>)defront.Value;
if (false != item.IsExpire(intervalMinuteTime))
{
result.Add(item);
}
}
foreach (CCacheItem_WuQi <K, T> item in result)
{
obj_containers.Remove(item.key);
}
}
catch (System.Exception e)
{
CExceptionContainer_WuQi.ProcessException(e);
throw e;
}
finally
{
obj_rwl.ReleaseWriterLock();
}
}
/// <summary>
/// 获取写者锁
/// </summary>
public void AcquireWriterLock()
{
m_lock.AcquireWriterLock(-1);
}
