class Fluent::PluginHelper::Storage::SynchronizeWrapper

def delete(key) 

def delete(key)
  @monitor.synchronize{ @storage.delete(key) }
end

def fetch(key, defval) 

def fetch(key, defval)
  @monitor.synchronize{ @storage.fetch(key, defval) }
end

def get(key) 

def get(key)
  @monitor.synchronize{ @storage.get(key) }
end

def implementation 

def implementation
  @storage
end

def initialize(storage) 

def initialize(storage)
  @storage = storage
  @monitor = Monitor.new
end

def load 

def load
  @monitor.synchronize do
    @storage.load
  end
end

def method_missing(name, *args) 

def method_missing(name, *args)
  @monitor.synchronize{ @storage.__send__(name, *args) }
end

def put(key, value) 

def put(key, value)
  @monitor.synchronize{ @storage.put(key, value) }
end

def save 

def save
  @monitor.synchronize do
    @storage.save
  end
end

def synchronized? 

def synchronized?
  true
end

def update(key, &block) 

def update(key, &block)
  @monitor.synchronize do
    v = block.call(@storage.get(key))
    @storage.put(key, v)
    v
  end
end