From: "headius (Charles Nutter)" <headius@...>
Date: 2013-09-27T20:40:54+09:00
Subject: [ruby-core:57442] [CommonRuby - Feature #8961] Synchronizable	module to easily wrap methods in a mutex


Issue #8961 has been updated by headius (Charles Nutter).


I would like to see this in 2.1, as a standard Module method. The fact that "def" returns the method name now makes this really easy.

I think this would need to be implemented natively to work, however. The prototype above has a key flaw: there's no guarantee that only one Monitor will be created, so two threads could execute the same method at the same time, synchronizing against different monitors. Putting the synchronized wrapper into C code would prevent a potential context switch when first creating the Monitor instance (or it could simply use some other mechanism, such as normal Object monitor synchronization in JRuby).

This feature is similar to an extension in JRuby called JRuby::Synchronized that causes all method lookups to return synchronized equivalents.

Combined with https://bugs.ruby-lang.org/issues/8556 this could go a very long way toward giving Ruby users better tools to write thread-safe code.
----------------------------------------
Feature #8961: Synchronizable module to easily wrap methods in a mutex
https://bugs.ruby-lang.org/issues/8961#change-42047

Author: tobiassvn (Tobias Svensson)
Status: Open
Priority: Normal
Assignee: 
Category: 
Target version: 


I propose a Synchronizable mixin to easily wrap methods in a mutex which works together with Ruby 2.1's method name symbols returned from 'def'.

The Mixin adds a new 'synchronized' class method which would alias the referenced method and redefines the original method wrapped in a 'synchronize do .. end' block.

This is probably somewhat related and an alternative to #8556.

--

Proof of concept (I've used Monitor here so potential users won't have to worry about reentrancy):

require 'monitor'
 
module Synchronizable
  module ClassMethods
    def synchronized(method)
      aliased = :"#{method}_without_synchronization"
      alias_method aliased, method
 
      define_method method do |*args, &block|
        monitor.synchronize do
          __send__(aliased, *args, &block)
        end
      end
    end
  end
 
  def monitor
    @monitor ||= Monitor.new
  end
 
  def self.included(base)
    base.extend(ClassMethods)
  end
end
 
class Foo
  include Synchronizable
 
  synchronized def bar
    # ...
  end
end



-- 
http://bugs.ruby-lang.org/