Introduction
So, here I got again into another problem, and no search results gave me the answer I was looking for. The software in development was mostly using only one thread to run, but sometimes it could happen that concurrent threads start to run to update some parts of the software (this is a real-time software). That's where I discovered that some methods weren't thread safe. So what could be my solution? I decided to build an object which could be used to synchronize threads within one or more methods of another object (and possibly multiple objects). This object should respond to these criteria:
- Is able to support enough concurrent threads (more than 50)
- Is deployable at least within a singleton object so that all calls made to specific methods are synchronized
- The entry order doesn't have to respect the exit order necessarily
- Is able to make threads wait as long as needed.
Thus was born the MethodSynchronizer
!!
Usability
This sample is to test the capacity of the
MethodSynchronizer
.
The MethodSynchronizer
is used to synchronize certain moments in your code where multiple threads could run at the same the time. You have to use one object per synchronization grouping. I mean there that, if for example you have an object which is used to read and write to the DB, then you can use one MethodSynchronizer
and call, at the beginning of each DBObject
methods, InternalThreadSync
method to synch all DB calls. Each end of DBOject
method has to have a ThreadIsEnded
call to let the flow continue. Otherwise, your program will crash. So, ensure that you have a ThreadIsEnded
call each time you use InternalThreadSync
for all your code flow possibilities.
This object is really easy to use. The only thing you have to care of is where you declare your MethodSynchronizer
object. Because this object isn't a Singleton (search this site for Singleton pattern if needed), you have to ensure that the methods using the MethodSynchronizer
use the same MethodSynchronizer
. So, if you use this within a singleton object, there is no problem; otherwise, you could declare it at a higher level of your program and make a reference to the object using it.
More
I'm been using this sample to get up to 948 concurrent threads processed one after the other. After that, an
OutOfMemoryException
is thrown by the program.
The reason why I didn't create this object as a Singleton is because I wanted to have the possibility to lock different parts of my software at the same time but not together. So one is independent of the other.
This object should be used when you have to lock for something that could take time. This is really useful when you get external access to your software, which could be anything like DB access, file, webpage, network,... and you only want ONE thread at a time to execute this code.
I hope this could be more useful! If you have questions or comments, send them to thecodeproject@cints.net, or use the forum below.
This member has not yet provided a Biography. Assume it's interesting and varied, and probably something to do with programming.