FIX: move the font lock higher up the call and class tree

We have for a long time (~2012) had an RLock on `RenderAgg` that was used in
`FigureCanvasAgg.draw` to protect the shared cache of ft2font objects (the
underlying c++ is very stateful and not thread safe). This lock was also
implicitly protecting the mathtext cache when using the Agg backend.

However, given the recent improvements to the layout code there are now ways to
call call `Figure.draw(renderer)` without acquiring this lock which leads to
exceptions when using mathtext and a layout manager to save independent figures
on different threads.

This bug also exists for the other backendends which use both the mathtext
parser and the ft2font cache in the case of rendering texts as paths (in the
vector backends).

The fix is to:

 - pull the lock up to `Figure` so all renderer instances effectively share a
   single lock
 - acquire the lock in `Figure.draw` which is always the top entry point to
   rendering a Figure.

Closes matplotlib#26289

Co-authored-by: Greg Lucas <[email protected]>

Author: tacaswell

lib/matplotlib/backend_bases.py

@@ -170,7 +170,6 @@ class RendererBase:
     * `draw_path_collection`
     * `draw_quad_mesh`
     """
-
     def __init__(self):
         super().__init__()
         self._texmanager = None
@@ -2147,9 +2146,10 @@ def print_figure(
                     functools.partial(
                         print_method, orientation=orientation)
                 )
+                # we do this instead of `self.figure.draw_without_rendering`
+                # so that we can inject the orientation
                 with getattr(renderer, "_draw_disabled", nullcontext)():
                     self.figure.draw(renderer)
-
             if bbox_inches:
                 if bbox_inches == "tight":
                     bbox_inches = self.figure.get_tightbbox(

lib/matplotlib/backends/backend_agg.py

@@ -23,7 +23,6 @@
 
 from contextlib import nullcontext
 from math import radians, cos, sin
-import threading
 
 import numpy as np
 
@@ -62,19 +61,6 @@ class RendererAgg(RendererBase):
     context instance that controls the colors/styles
     """
 
-    # we want to cache the fonts at the class level so that when
-    # multiple figures are created we can reuse them.  This helps with
-    # a bug on windows where the creation of too many figures leads to
-    # too many open file handles.  However, storing them at the class
-    # level is not thread safe.  The solution here is to let the
-    # FigureCanvas acquire a lock on the fontd at the start of the
-    # draw, and release it when it is done.  This allows multiple
-    # renderers to share the cached fonts, but only one figure can
-    # draw at time and so the font cache is used by only one
-    # renderer at a time.
-
-    lock = threading.RLock()
-
     def __init__(self, width, height, dpi):
         super().__init__()
 
@@ -395,8 +381,7 @@ def draw(self):
         self.renderer = self.get_renderer()
         self.renderer.clear()
         # Acquire a lock on the shared font cache.
-        with RendererAgg.lock, \
-             (self.toolbar._wait_cursor_for_draw_cm() if self.toolbar
+        with (self.toolbar._wait_cursor_for_draw_cm() if self.toolbar
               else nullcontext()):
             self.figure.draw(self.renderer)
             # A GUI class may be need to update a window using this draw, so

lib/matplotlib/figure.py

@@ -35,6 +35,7 @@
 import itertools
 import logging
 from numbers import Integral
+import threading
 
 import numpy as np
 
@@ -2365,6 +2366,18 @@ class Figure(FigureBase):
         *suppressComposite* is a boolean, this will override the renderer.
     """
 
+    # we want to cache the fonts and mathtext at a global level so that when
+    # multiple figures are created we can reuse them.  This helps with a bug on
+    # windows where the creation of too many figures leads to too many open
+    # file handles and improves the performance of parsing mathtext.  However,
+    # these global caches are not thread safe.  The solution here is to let the
+    # Figure acquire a shared lock at the start of the draw, and release it when it
+    # is done.  This allows multiple renderers to share the cached fonts and
+    # parsed text, but only one figure can draw at a time and so the font cache
+    # and mathtext cache are used by only one renderer at a time.
+
+    _render_lock = threading.RLock()
+
     def __str__(self):
         return "Figure(%gx%g)" % tuple(self.bbox.size)
 
@@ -3124,33 +3137,33 @@ def clear(self, keep_observers=False):
     @allow_rasterization
     def draw(self, renderer):
         # docstring inherited
-
-        # draw the figure bounding box, perhaps none for white figure
         if not self.get_visible():
             return
 
-        artists = self._get_draw_artists(renderer)
-        try:
-            renderer.open_group('figure', gid=self.get_gid())
-            if self.axes and self.get_layout_engine() is not None:
-                try:
-                    self.get_layout_engine().execute(self)
-                except ValueError:
-                    pass
-                    # ValueError can occur when resizing a window.
+        with self._render_lock:
 
-            self.patch.draw(renderer)
-            mimage._draw_list_compositing_images(
-                renderer, self, artists, self.suppressComposite)
+            artists = self._get_draw_artists(renderer)
+            try:
+                renderer.open_group('figure', gid=self.get_gid())
+                if self.axes and self.get_layout_engine() is not None:
+                    try:
+                        self.get_layout_engine().execute(self)
+                    except ValueError:
+                        pass
+                        # ValueError can occur when resizing a window.
 
-            for sfig in self.subfigs:
-                sfig.draw(renderer)
+                self.patch.draw(renderer)
+                mimage._draw_list_compositing_images(
+                    renderer, self, artists, self.suppressComposite)
 
-            renderer.close_group('figure')
-        finally:
-            self.stale = False
+                for sfig in self.subfigs:
+                    sfig.draw(renderer)
+
+                renderer.close_group('figure')
+            finally:
+                self.stale = False
 
-        DrawEvent("draw_event", self.canvas, renderer)._process()
+            DrawEvent("draw_event", self.canvas, renderer)._process()
 
     def draw_without_rendering(self):
         """