How to make a shared resource thread-safe when using dependency injection?

Question

My current application is using single instance of an object as a global variable for many of the main components, which I understand is considered inferior to using dependency injection.

I wish to make my applications open source in the future, but first I want to refactor the code to use the most recommended techniques for team collaboration so that other developers will be able to change my source code more easily.

Example of a shared resource: In the CFML language, you have the Server scope, which is shared memory that is available to any request for the entire server instance.

Here is my new design concept for managing changes to the Server scope:

Create a single instance of component named ServerMemoryManager which provides an interface for writing and reading to the server scope.
Any other code that needs to access the server scope will be injected with a reference to the single instance of the ServerMemoryManager via an init() function or a setServerMemoryManager() function.
Whenever a component reads/writes data to the ServerMemoryManager object, it will be able to internally lock the server scope so that no 2 threads can simultaneous write to the same piece of memory in the server scope.

Is this the best way to manage a shared resource (shared memory, filesystem, etc) that requires locking in order to be thread-safe?

Please describe any additional methods that can be used to manage a shared resource that requires locking during certain read/write operations which are considered best practices.

Edit: Based on the accepted answer, instead of locking scope="server", I will use named locks and manage the shared resources with more fine-grained locking. This may allow using multiple objects to manage the shared resources assuming they are all managing different keys in shared memory or files in the filesystem. For example, one application could have its own unique key or directory assigned to it so that it wouldn't conflict with another application trying to change a shared resource.

Edit2: I found I could use a single component named scope.cfc for each scope if I pass the scope into the init function when I create the object. I am now using fine-grained named locks. Let me know if it can be improved. The actual revised code now looks like this (I excluded the code for read, delete, clear). It also doesn't seem that it is required to have a single instance of the scope.cfc component anymore.

            
                
                variables.scope=false;
                variables.scopeName=false;
                
                
                    
                    
                    
                    variables.scope=arguments.scope;
                    variables.scopeName=arguments.scopeName;
                    return this;
                    
                
                
                    
                    
                    
                    
                        
                            
                            variables.scope[arguments.key]=arguments.value;

** Edit3:** I tested the performance of reading from server scope through a component method like this and found it to be 20 times slower then reading the server scope directly when using a read only lock and 4 times slower without a lock. The overhead of an extra function call hundreds or thousands of times per request will be too slow. Tests done on Railo 3.3.x.

I prefer to build a large object in a non-public request and then set a single shared memory scope key then try to write an incomplete object to the scopes. Example:


ts=structnew();
ts.largeObject=buildLargeObject();
server.cachedObject=ts;

This lets you avoid locking across the entire application when you only write complete objects to shared memory since updating a single struct key is thread-safe. However, when you build the large object on startup, you need to be sure it is locked until that object is fully created.

I'm going to make the scope variable become directly readable by using the this scope instead of variables scope in the init function to avoid slowing down the application.

genericHCU · Accepted Answer

CFLOCK only prevents code from executing if every occurrence is locked the same way.

For example:

page1.cfm

page2.cfm

Page2.cfm is going to negate any locks you have on page1.cfm if page2 runs the same time page1 does. That said, it's good that you are locking inside your cfc so that each object doesn't have to be locked.

However, locking every occurrence isn't enough. The following won't do much good either.

page1.cfm

page2.cfm

This will halt the processing for every request of page1 and page2 but will not protect application.xyz on page1 from changes made to application.xyz on page2. To do this you need to give your locks a "name".

Locks name. Mutually exclusive with the scope attribute. Only one request can execute the code within a cflocktag with a given name at a time. Cannot be an empty string.

Permits synchronizing access to resources from different parts of an application. Lock names are global to a ColdFusion server. They are shared among applications and user sessions, but not clustered servers.

Because you are creating multiple instances of your object, I believe serverMemoryManagerObject could interfere with serverMemoryManagerObject2 unless you name your lock.

Here is some more information about locking dos and don'ts

How to make a shared resource thread-safe when using dependency injection?

Answers (1)

Related Questions