Due to the fact my background
is in financial markets (trading systems to be exact), I find my self continuously
trying to scrounge up milliseconds by code improvements. My
weapon of choice is parallel processing or otherwise called threading. Over
the years it has been both my greatest asset any my most malevolent foe. Many
have commented on the impeding doom of mutable states and many core processors in
software design; hence functional programming.
I
have aspiration to neither speak about functional programming nor give a class on
threading best practices. Instead, I
am interested in providing an easier ReaderWriterLock schematic; most likely to the
joy of my team.
The
“lock{}” keyword (or “SyncLock” keyword for VB.NET) is very useful and concise in
its usage; though anyone trying to squeeze milliseconds knows the performance benefits
of a ReaderWriterLock in many cases. (Stop
here if the previous statement doesn’t make sense to you and go Google the ReaderWriterLock.) However,
the implementation of a ReaderWriterLock requires much more code and can cause dead
locks if implemented incorrectly.
Thus,
I came up with the attached solution. It
offers improvements on two fronts. One,
it allows a user to retry a function N number of times before raising an exception. Second,
it ensures the locks are acquired and released correctly.
I
am not exactly thrilled with this design because the use of anonymous methods makes
for a non simple solution. Nevertheless,
I think it is better then writing the internalized code in ever method that needs
to be locked. Finally, I have not performance
tested this yet; but I will post later with results.
public
class ClassThanNeedsLocking
{ ReTryReaderWriterLock _rw =new ReTryReaderWriterLock(); private Dictionary<double, double>
_valueMap; public ClassThanNeedsLocking()
{ this._valueMap =new Dictionary<double, double>();
} publicvoid AddSomething(double key, double value)
{ ReTryReaderWriterLock.FunctionalityToLock temp =delegate { this._valueMap.Add(key,
value); }; this._rw.WriterLockFunction(temp,
100, 5, 10); } publicdouble GetSomething(double key)
{ double value = 0;
ReTryReaderWriterLock.FunctionalityToLock temp =delegate { if (this._valueMap.TryGetValue(key, out value))
{ thrownew ArgumentException("Key
Does Not Exist.", "key");
} }; this._rw.ReaderLockFunction(temp,
100, 5, 10); return value;
} } publicclass ReTryReaderWriterLock
{ publicdelegatevoid FunctionalityToLock(); privatedelegatevoid RepeatTryLock(int timesTried); private ReaderWriterLock
_rw =new ReaderWriterLock(); private ILock
_reader =new ReaderLock(); private ILock
_writer =new WriterLock(); publicvoid ReaderLockFunction(FunctionalityToLock
function, int timeOutPerTry, int timesToTry, int timeToWaitBeforeTryingAgain)
{ LockFunction(function, timeOutPerTry, timesToTry, timeToWaitBeforeTryingAgain, this._reader);
} publicvoid WriterLockFunction(FunctionalityToLock
function, int timeOutPerTry, int timesToTry, int timeToWaitBeforeTryingAgain)
{ LockFunction(function, timeOutPerTry, timesToTry, timeToWaitBeforeTryingAgain, this._writer);
} privatevoid LockFunction(FunctionalityToLock
function, int timeOutPerTry, int timesToTry, int timeToWaitBeforeTryingAgain,
ILock typeOfLock) { RepeatTryLock repeater =null;
repeater =delegate(int timesTried)
{ try {
typeOfLock.Acquire(this._rw,
timeOutPerTry); function(); } catch (ApplicationException)
{ if (timesTried
< timesToTry) { Thread.Sleep(timeToWaitBeforeTryingAgain); timesTried += 1; repeater(timesTried); return;
} throw;
} finally {
typeOfLock.Release(this._rw);
} }; repeater(0); } privateinterface ILock
{ void Acquire(ReaderWriterLock
rw, int timeOutPerTry); void Release(ReaderWriterLock
rw); } privateclass ReaderLock
: ILock { publicvoid Acquire(ReaderWriterLock
rw, int timeOutPerTry)
{ rw.AcquireReaderLock(timeOutPerTry); } publicvoid Release(ReaderWriterLock
rw) { if (rw.IsReaderLockHeld
== true)
{ rw.ReleaseReaderLock(); } } } privateclass WriterLock
: ILock { publicvoid Acquire(ReaderWriterLock
rw, int timeOutPerTry)
{ rw.AcquireWriterLock(timeOutPerTry); } publicvoid Release(ReaderWriterLock
rw) { if (rw.IsWriterLockHeld
== true)
{ rw.ReleaseWriterLock(); } } } }
This weblog is sponsored by
IFinancialSystems.
