Make MemoryAdapter thread-safe with Monitor

The MemoryAdapter used a plain Hash with no synchronization,
causing race conditions in multi-threaded servers (Puma, Sidekiq).
fetch did a non-atomic exist?-then-write, allowing concurrent
threads to duplicate work or corrupt state.

Changes:
- Wrap all cache operations with Monitor#synchronize
- Make fetch atomic (inline key check + write under one lock)
- Add frozen_string_literal pragma
- Update tests to assert cache state directly instead of
  mocking internal write calls

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: agrberg

lib/cacheable/cache_adapters/memory_adapter.rb

@@ -1,42 +1,50 @@
+# frozen_string_literal: true
+
+require 'monitor'
+
 module Cacheable
   module CacheAdapters
     class MemoryAdapter
       def initialize
+        @monitor = Monitor.new
         clear
       end
 
       def read(key)
-        cache[key]
+        @monitor.synchronize { @cache[key] }
       end
 
       def write(key, value)
-        cache[key] = value
+        @monitor.synchronize { @cache[key] = value }
       end
 
       def exist?(key)
-        cache.key?(key)
+        @monitor.synchronize { @cache.key?(key) }
       end
 
+      # NOTE: yield is intentionally called inside the lock to prevent thundering herd — only one thread
+      # computes a missing value while others wait. This is acceptable for a simple in-memory adapter;
+      # production use cases needing high concurrency should use a real cache backend via CacheAdapter.
       def fetch(key, _options = {})
-        return read(key) if exist?(key)
+        @monitor.synchronize do
+          return @cache[key] if @cache.key?(key)
 
-        write(key, yield)
+          @cache[key] = yield
+        end
       end
 
-      def delete(key) # rubocop:disable Naming/PredicateMethod -- mimics the ActiveSupport::Cache::Store#delete interface and isn't a predicate
-        return false unless exist?(key)
+      def delete(key)
+        @monitor.synchronize do
+          return false unless @cache.key?(key)
 
-        cache.delete key
-        true
+          @cache.delete(key)
+          true
+        end
       end
 
       def clear
-        @cache = {}
+        @monitor.synchronize { @cache = {} }
       end
-
-      private
-
-      attr_reader :cache
     end
   end
 end

spec/cacheable/cacheable_spec.rb

@@ -366,8 +366,10 @@
           cacheable(*local_variable_so_class_eval_works)
         end
 
-        expect(described_class.cache_adapter).to receive(:write).twice.and_call_original
         2.times { cache_methods.each { |method| cacheable_object.send(method) } }
+        cache_methods.each do |method|
+          expect(described_class.cache_adapter.exist?([method])).to be true
+        end
       end
 
       it 'uses the same options for cacheable methods declared on a single line' do
@@ -377,8 +379,10 @@
           cacheable(*local_variable_so_class_eval_works, unless: proc { true })
         end
 
-        expect(described_class.cache_adapter).not_to receive(:write)
         2.times { cache_methods.each { |method| cacheable_object.send(method) } }
+        cache_methods.each do |method|
+          expect(described_class.cache_adapter.exist?([method])).to be false
+        end
       end
 
       it 'can take strings' do
@@ -388,8 +392,10 @@
           cacheable(*cache_methods_as_strings)
         end
 
-        expect(described_class.cache_adapter).to receive(:write).twice.and_call_original
         2.times { cache_methods.each { |method| cacheable_object.send(method) } }
+        cache_methods_as_strings.each do |method|
+          expect(described_class.cache_adapter.exist?([method])).to be true
+        end
       end
 
       it 'can take strings before the method is defined' do