Don't clear view cache during concurrent requests

This updates ActionView::CacheExpiry to hold a lock while inside the
executor (ie. inside a request) and to only clear caches when that is
done.

This is done using Concurrent::ReadWriteLock. This allows any number
of parallel requests to hold the read lock, but once we detect a change
and begin to acquire the write lock, all future requests will be
blocked.

actionview/lib/action_view/cache_expiry.rb

@@ -4,49 +4,63 @@ module ActionView
   class CacheExpiry
     class Executor
       def initialize(watcher:)
-        @cache_expiry = CacheExpiry.new(watcher: watcher)
-      end
-
-      def before(target)
-        @cache_expiry.clear_cache_if_necessary
-      end
-    end
-
-    def initialize(watcher:)
-      @watched_dirs = nil
-      @watcher_class = watcher
-      @watcher = nil
-      @mutex = Mutex.new
-    end
-
-    def clear_cache_if_necessary
-      @mutex.synchronize do
-        watched_dirs = dirs_to_watch
-        return if watched_dirs.empty?
-
-        if watched_dirs != @watched_dirs
-          @watched_dirs = watched_dirs
-          @watcher = @watcher_class.new([], watched_dirs) do
-            clear_cache
-          end
-          @watcher.execute
-        else
-          @watcher.execute_if_updated
+        @execution_lock = Concurrent::ReadWriteLock.new
+        @cache_expiry = ViewModificationWatcher.new(watcher: watcher) do
+          clear_cache
         end
       end
-    end
 
-    def clear_cache
-      ActionView::LookupContext::DetailsKey.clear
-    end
-
-    private
-      def dirs_to_watch
-        all_view_paths.grep(FileSystemResolver).map!(&:path).tap(&:uniq!).sort!
+      def run
+        ActiveSupport::Dependencies.interlock.permit_concurrent_loads do
+          @cache_expiry.execute_if_updated
+          @execution_lock.acquire_read_lock
+        end
       end
 
-      def all_view_paths
-        ActionView::ViewPaths.all_view_paths.flat_map(&:paths)
+      def complete(_)
+        @execution_lock.release_read_lock
       end
+
+      private
+        def clear_cache
+          @execution_lock.with_write_lock do
+            ActionView::LookupContext::DetailsKey.clear
+          end
+        end
+    end
+
+    class ViewModificationWatcher
+      def initialize(watcher:, &block)
+        @watched_dirs = nil
+        @watcher_class = watcher
+        @watcher = nil
+        @mutex = Mutex.new
+        @block = block
+      end
+
+      def execute_if_updated
+        @mutex.synchronize do
+          watched_dirs = dirs_to_watch
+          return if watched_dirs.empty?
+
+          if watched_dirs != @watched_dirs
+            @watched_dirs = watched_dirs
+            @watcher = @watcher_class.new([], watched_dirs, &@block)
+            @watcher.execute
+          else
+            @watcher.execute_if_updated
+          end
+        end
+      end
+
+      private
+        def dirs_to_watch
+          all_view_paths.grep(FileSystemResolver).map!(&:path).tap(&:uniq!).sort!
+        end
+
+        def all_view_paths
+          ActionView::ViewPaths.all_view_paths.flat_map(&:paths)
+        end
+    end
   end
 end

actionview/lib/action_view/railtie.rb

@@ -98,7 +98,7 @@ module ActionView
       end
 
       unless enable_caching
-        app.executor.to_run ActionView::CacheExpiry::Executor.new(watcher: app.config.file_watcher)
+        app.executor.register_hook ActionView::CacheExpiry::Executor.new(watcher: app.config.file_watcher)
       end
     end