Custom Control Structures In Ruby

Thread Safety with Synchronized Blocks

When writing programs that use multiple threads, it is important that two threads do not attempt to modify the same object at the same time. One way to do this is to place the code that must be made thread-safe in a block associated with a call to the synchronize method of a Mutex object.\In Example below, we take this a step further, and emulate Java’s synchronized keyword with a global method named synchronized. This synchronized method expects a single object argument and a block. It obtains a Mutex associated with the object, and uses Mutex.synchronize to invoke the block. The tricky part is that Ruby’s object, unlike Java’s objects, do not have a Mutex associated with them. So below Example also defines an instance method named mutex in Object. Interestingly, the implementation of this mutex method uses synchronized in its new keyword-style form!

require 'thread'      # Ruby 1.8 keeps Mutex in this library 
# Obtain the Mutex associated with the object o, and then evaluate 
# the block under the protection of that Mutex. 
# This works like the synchronized keyword of Java. 
def synchronized(o) o.mutex.synchronize { yield } 
end 
# Object.mutex does not actually exist. We've got to define it. 
# This method returns a unique Mutex for every object, and 
# always returns the same Mutex for any particular object.
# It creates Mutexes lazily, which requires synchronization for
# thread safety.
class Object 
# Return the Mutex for this object, creating it if necessary. 
# The tricky part is making sure that two threads don't call 
# this at the same time and end up creating two different mutexes. 
def mutex 
# If this object already has a mutex, just return it 
return @__mutex if @__mutex
# Otherwise, we've got to create a mutex for the object. 
# To do this safely we've got to synchronize on our class object.
synchronized(self.class) { 
# Check again: by the time we enter this synchronized block, 
# some other thread might have already created the mutex. 
@__mutex = @__mutex || Mutex.new 
} 
# The return value is @__mutex 
end 
end 
# The Object.mutex method defined above needs to lock the class 
# if the object doesn't have a Mutex yet. If the class doesn't have 
# its own Mutex yet, then the class of the class (the Class object) 
# will be locked. In order to prevent infinite recursion, we must 
# ensure that the Class object has a mutex. 
Class.instance_eval { @__mutex = Mutex.new }

Frequently Asked Questions

What is Ruby?

Ruby is an open-source dynamic and object-oriented programming language. It is an interpreted language that means source code is compiled by an interpreter at the time of execution.

What are the uses of Ruby?

Ruby is generally used for building web applications. It is a general-purpose programming language and finds many applications in data analysis, prototyping, and proof of concept.

Conclusion

In this article,we discussed about ruby,and its custom control structure.

Refer to our Guided Path on Coding Ninjas Studio to upskill yourself in Data Structures and Algorithms, Competitive Programming, JavaScript, System Design, Machine learning and many more! If you want to test your competency in coding, you may check out the mock test series and participate in the contests hosted on Coding Ninjas Studio! But if you have just started your learning process and are looking for questions asked by tech giants like Amazon, Microsoft, Uber, etc; you must look at the problems, interview experiences, and interview bundle for placement preparations.

Nevertheless, you may consider our paid courses to give your career an edge over others!

Do upvote our blogs if you find them helpful and engaging!

Happy Learning!!