Reuse the main display's font across displays when already available

Now that each display keeps its own font cache, a symbolic name
requested from several displays ends up with a separate native font
handle per display, even for names that never vary between displays,
such as the JFace default font.

Prefer a font already realized on the registry's main display whenever
it has the exact style requested; only when it does not does the
requesting display realize and cache one of its own. This keeps
resource usage close to what a single shared cache would give, while
remaining correct per display. Callers without a display of their own,
which so far could only fall back to the default font, reuse any
already realized font the same way.

Handing a font owned by the main display to another display is safe
because the main display outlives every other display the registry is
used from, so the font cannot be disposed while another display still
uses it. The flip side is that the font returned for a symbolic name is
no longer necessarily owned by the caller's display.

A display that had to realize a font itself keeps getting that one, so
repeated lookups do not silently switch to a different instance once
the main display catches up. That costs nothing, since such a copy only
exists where it had to be created anyway.

Reusing only a record that already carries the requested style also
keeps the lazy creation of styled fonts confined to the display owning
the record, so it needs no synchronization of its own.

Since all of this depends on which style is being asked for, the style
is now known while a record is looked up, rather than being applied to
the record only afterwards.

Tests cover reuse when the style is already available on the main
display, falling back to a display's own font when it is not, and reuse
starting once the main display realizes the style later.

Assisted-by: Claude Opus 5 <noreply@anthropic.com>

Author: HeikoKlare

bundles/org.eclipse.jface/src/org/eclipse/jface/resource/FontRegistry.java

@@ -64,6 +64,10 @@
 @NoExtend
 public class FontRegistry extends ResourceRegistry {
 
+	private enum FontStyle {
+		NORMAL, BOLD, ITALIC
+	}
+
 	/**
 	 * FontRecord is a private helper class that holds onto a font
 	 * and can be used to generate its bold and italic version.
@@ -109,16 +113,29 @@ void dispose() {
 		 * Return the base Font.
 		 * @return Font
 		 */
-		public Font getBaseFont() {
+		private Font getBaseFont() {
 			return baseFont;
 		}
 
+		/**
+		 * Return the font for the given style, creating it lazily if necessary.
+		 * @param style the requested style
+		 * @return the font
+		 */
+		public Font get(FontStyle style) {
+			return switch (style) {
+				case NORMAL -> getBaseFont();
+				case BOLD -> getBoldFont();
+				case ITALIC -> getItalicFont();
+			};
+		}
+
 		/**
 		 * Return the bold Font. Create a bold version
 		 * of the base font to get it.
 		 * @return Font
 		 */
-		public Font getBoldFont() {
+		private Font getBoldFont() {
 			if (boldFont != null) {
 				return boldFont;
 			}
@@ -132,6 +149,20 @@ public Font getBoldFont() {
 			return boldFont;
 		}
 
+		/**
+		 * Returns whether the given style has already been realized for this
+		 * record.
+		 * @param style the style to check
+		 * @return whether the given style is already available
+		 */
+		public boolean has(FontStyle style) {
+			return switch (style) {
+				case NORMAL -> baseFont != null;
+				case BOLD -> boldFont != null;
+				case ITALIC -> italicFont != null;
+			};
+		}
+
 		/**
 		 * Get a version of the base font data with the specified
 		 * style.
@@ -158,7 +189,7 @@ private FontData[] getModifiedFontData(int style) {
 		 * base font to get it.
 		 * @return Font
 		 */
-		public Font getItalicFont() {
+		private Font getItalicFont() {
 			if (italicFont != null) {
 				return italicFont;
 			}
@@ -236,7 +267,7 @@ void invalidate(String symbolicName) {
 				return;
 			}
 			FontRecord defaultRecord = records.get(JFaceResources.DEFAULT_FONT);
-			Font defaultFont = defaultRecord != null ? defaultRecord.getBaseFont() : null;
+			Font defaultFont = defaultRecord != null ? defaultRecord.get(FontStyle.NORMAL) : null;
 			replacedRecord.getAllocatedFonts().stream().filter(font -> font != defaultFont).forEach(staleFonts::add);
 		}
 
@@ -605,7 +636,16 @@ Font calculateDefaultFont() {
 	 * @return Font
 	 */
 	public Font defaultFont() {
-		return defaultFontRecord().getBaseFont();
+		return defaultFont(FontStyle.NORMAL);
+	}
+
+	/**
+	 * Return the default font in the given style, creating it if necessary.
+	 * @param style the requested style
+	 * @return the font
+	 */
+	private Font defaultFont(FontStyle style) {
+		return defaultFontRecord(style).get(style);
 	}
 
 	/**
@@ -628,14 +668,12 @@ public FontDescriptor getDescriptor(String symbolicName) {
 	/**
 	 * Returns the default font record.
 	 */
-	private FontRecord defaultFontRecord() {
-		FontRecord record = getExistingFontRecord(JFaceResources.DEFAULT_FONT);
+	private FontRecord defaultFontRecord(FontStyle style) {
+		FontRecord record = getExistingFontRecord(JFaceResources.DEFAULT_FONT, style);
 		if (record == null && Display.getCurrent() == null) {
-			// No display for the current thread, so there is none to scope the
-			// lookup to and none to create a font on. Fall back to the default
-			// font already realized on the main display, which outlives every
-			// other display, rather than fail outright. Reached e.g. from
-			// getFontRecord()'s non-UI-thread fallback.
+			// no display to scope the lookup to and none to create a font on: use the
+			// main display's record even if the requested style is not realized there
+			// yet, so the style gets realized on that display rather than failing
 			DisplayFontRecords mainDisplayRecords = displayToFontRecords.get(mainDisplay);
 			if (mainDisplayRecords != null) {
 				record = mainDisplayRecords.get(JFaceResources.DEFAULT_FONT);
@@ -659,24 +697,61 @@ record = createFont(JFaceResources.DEFAULT_FONT, defaultFont.getFontData());
 	}
 
 	/**
-	 * Looks up an already-realized font record for the given symbolic name on
-	 * the current display. Returns <code>null</code> if there is none, in which
-	 * case the caller is responsible for creating one on the current display.
+	 * Looks up an already-realized font record for the given symbolic name and
+	 * style: the main display's record is preferred whenever it already has the
+	 * exact style requested (so callers from any display, including a thread
+	 * with no Display of its own, reuse it instead of allocating a duplicate),
+	 * otherwise the current display's own record (if any) is used. Returns
+	 * <code>null</code> if neither has a matching record, in which case the
+	 * caller is responsible for creating one on the current display.
+	 * <p>
+	 * Handing out the main display's font to another display is safe because
+	 * the main display is assumed to outlive every other display the registry
+	 * is used from, so the font cannot be disposed while another display is
+	 * still using it.
+	 * </p>
+	 * <p>
+	 * Requiring the exact style to be present is also what keeps the lazy
+	 * creation of styled fonts single-threaded: a record is only ever handed to
+	 * a foreign thread once the style it asks for has been realized, so only
+	 * the record's own display ever reaches the creating branch of
+	 * {@link FontRecord#get(FontStyle)}. Note that this means the main
+	 * display's record always wins for {@link FontStyle#NORMAL}, whose font is
+	 * realized when the record is created.
+	 * </p>
 	 */
-	private FontRecord getExistingFontRecord(String symbolicName) {
+	private FontRecord getExistingFontRecord(String symbolicName, FontStyle style) {
+		FontRecord recordOnCurrentDisplay = null;
 		Display currentDisplay = Display.getCurrent();
-		if (currentDisplay == null) {
-			return null;
+		if (currentDisplay != null) {
+			DisplayFontRecords currentDisplayRecords = displayToFontRecords.get(currentDisplay);
+			if (currentDisplayRecords != null) {
+				recordOnCurrentDisplay = currentDisplayRecords.get(symbolicName);
+				// a style this display already realized itself stays the one it gets, so
+				// repeated lookups keep returning the same font instance
+				if (recordOnCurrentDisplay != null && recordOnCurrentDisplay.has(style)) {
+					return recordOnCurrentDisplay;
+				}
+			}
 		}
-		DisplayFontRecords currentDisplayRecords = displayToFontRecords.get(currentDisplay);
-		return currentDisplayRecords != null ? currentDisplayRecords.get(symbolicName) : null;
+
+		DisplayFontRecords mainDisplayRecords = displayToFontRecords.get(mainDisplay);
+		if (mainDisplayRecords != null) {
+			FontRecord recordOnMainDisplay = mainDisplayRecords.get(symbolicName);
+			// Only return main display record if exact font style already exists
+			if (recordOnMainDisplay != null && recordOnMainDisplay.has(style)) {
+				return recordOnMainDisplay;
+			}
+		}
+
+		return recordOnCurrentDisplay;
 	}
 
 	/**
 	 * Returns the default font data.  Creates it if necessary.
 	 */
 	private FontData[] defaultFontData() {
-		return defaultFontRecord().baseData;
+		return defaultFontRecord(FontStyle.NORMAL).baseData;
 	}
 
 	/**
@@ -713,8 +788,7 @@ public FontData[] getFontData(String symbolicName) {
 	 * @return the font
 	 */
 	public Font get(String symbolicName) {
-
-		return getFontRecord(symbolicName).getBaseFont();
+		return getFont(symbolicName, FontStyle.NORMAL);
 	}
 
 	/**
@@ -733,8 +807,7 @@ public Font get(String symbolicName) {
 	 * @since 3.0
 	 */
 	public Font getBold(String symbolicName) {
-
-		return getFontRecord(symbolicName).getBoldFont();
+		return getFont(symbolicName, FontStyle.BOLD);
 	}
 
 	/**
@@ -753,41 +826,41 @@ public Font getBold(String symbolicName) {
 	 * @since 3.0
 	 */
 	public Font getItalic(String symbolicName) {
-
-		return getFontRecord(symbolicName).getItalicFont();
+		return getFont(symbolicName, FontStyle.ITALIC);
 	}
 
 	/**
-	 * Return the font record for the key.
+	 * Return the font for the given key and style.
 	 * @param symbolicName The key for the record.
-	 * @return FontRecord
+	 * @param style the requested style
+	 * @return the font
 	 */
-	private FontRecord getFontRecord(String symbolicName) {
+	private Font getFont(String symbolicName, FontStyle style) {
 		Assert.isNotNull(symbolicName);
-		FontRecord existingRecord = getExistingFontRecord(symbolicName);
+		FontRecord existingRecord = getExistingFontRecord(symbolicName, style);
 		if (existingRecord != null) {
-			return existingRecord;
+			return existingRecord.get(style);
 		}
 
 		FontData[] existingFontData = stringToFontData.get(symbolicName);
 
 		FontRecord fontRecord;
 
 		if (existingFontData == null) {
-			fontRecord = defaultFontRecord();
+			fontRecord = defaultFontRecord(style);
 		} else {
 			fontRecord = createFont(symbolicName, existingFontData);
 		}
 
 		if (fontRecord == null) {
-			fontRecord = defaultFontRecord();
+			fontRecord = defaultFontRecord(style);
 			if (Display.getCurrent() == null) { // log error but don't throw an exception to preserve existing functionality
 				String msg = "Unable to create font \"" + symbolicName + "\" in a non-UI thread. Using default font instead."; //$NON-NLS-1$ //$NON-NLS-2$
 				Policy.logException(new SWTException(msg));
 			}
 		}
 
-		return fontRecord;
+		return fontRecord.get(style);
 	}
 
 	@Override

tests/org.eclipse.jface.tests/src/org/eclipse/jface/tests/resources/FontRegistryTest.java

@@ -97,6 +97,101 @@ public void multipleDisplayDispose_italicFont() {
 		testMultipleDisplayDispose(() -> fontRegistry.getItalic(JFaceResources.DEFAULT_FONT));
 	}
 
+	@Test
+	public void multipleDisplay_reusesMainDisplayFont_whenStyleAlreadyCached() {
+		assumeTrue(OS.isWindows(), "multiple Display instance only allowed on Windows");
+
+		FontRegistry fontRegistry = new FontRegistry();
+		fontRegistry.put("myfont", new FontData[] { new FontData("Arial", 12, SWT.NORMAL) });
+		Font mainFont = fontRegistry.get("myfont");
+
+		Display secondDisplay = initializeDisplayInSeparateThread();
+		try {
+			Font fontFromSecondDisplayThread = secondDisplay.syncCall(() -> fontRegistry.get("myfont"));
+			assertEquals(mainFont, fontFromSecondDisplayThread,
+					"a font already realized on the main display should be reused from any other display's thread");
+			assertEquals(Display.getCurrent(), fontFromSecondDisplayThread.getDevice(),
+					"the reused font is still owned by the main display");
+		} finally {
+			secondDisplay.syncExec(secondDisplay::dispose);
+		}
+	}
+
+	@Test
+	public void multipleDisplay_createsOwnFont_whenStyleNotYetCachedOnMainDisplay() {
+		assumeTrue(OS.isWindows(), "multiple Display instance only allowed on Windows");
+
+		FontRegistry fontRegistry = new FontRegistry();
+		fontRegistry.put("myfont", new FontData[] { new FontData("Arial", 12, SWT.NORMAL) });
+		fontRegistry.get("myfont"); // only realizes the NORMAL style on the main display
+
+		Display secondDisplay = initializeDisplayInSeparateThread();
+		Font boldFontOnSecondDisplay;
+		try {
+			boldFontOnSecondDisplay = secondDisplay.syncCall(() -> fontRegistry.getBold("myfont"));
+
+			assertEquals(secondDisplay, boldFontOnSecondDisplay.getDevice(),
+					"bold style is not yet cached on the main display, so it must be created on the requesting display");
+		} finally {
+			secondDisplay.syncExec(secondDisplay::dispose);
+		}
+		assertTrue(boldFontOnSecondDisplay.isDisposed(),
+				"fonts created for the second display must be disposed together with it");
+	}
+
+	@Test
+	public void multipleDisplay_reusesMainDisplayFont_onceStyleBecomesCachedThere() {
+		assumeTrue(OS.isWindows(), "multiple Display instance only allowed on Windows");
+
+		FontRegistry fontRegistry = new FontRegistry();
+		fontRegistry.put("myfont", new FontData[] { new FontData("Arial", 12, SWT.NORMAL) });
+		fontRegistry.get("myfont"); // only realizes the NORMAL style on the main display
+
+		Display firstSecondDisplay = initializeDisplayInSeparateThread();
+		Font boldFontOnFirstSecondDisplay = firstSecondDisplay.syncCall(() -> fontRegistry.getBold("myfont"));
+		assertEquals(firstSecondDisplay, boldFontOnFirstSecondDisplay.getDevice(),
+				"bold style is not yet cached on the main display, so it must be created on the requesting display");
+		firstSecondDisplay.syncExec(firstSecondDisplay::dispose);
+
+		// the main display now also realizes the bold style
+		Font boldFontOnMainDisplay = fontRegistry.getBold("myfont");
+
+		Display secondSecondDisplay = initializeDisplayInSeparateThread();
+		try {
+			Font boldFontOnSecondSecondDisplay = secondSecondDisplay.syncCall(() -> fontRegistry.getBold("myfont"));
+			assertEquals(boldFontOnMainDisplay, boldFontOnSecondSecondDisplay,
+					"once the main display has realized the requested style, later lookups from any display must reuse it");
+		} finally {
+			secondSecondDisplay.syncExec(secondSecondDisplay::dispose);
+		}
+	}
+
+	@Test
+	public void multipleDisplay_keepsOwnFont_whenMainDisplayRealizesItLater() {
+		assumeTrue(OS.isWindows(), "multiple Display instance only allowed on Windows");
+
+		FontRegistry fontRegistry = new FontRegistry();
+		fontRegistry.put("myfont", new FontData[] { new FontData("Arial", 12, SWT.NORMAL) });
+
+		Display secondDisplay = initializeDisplayInSeparateThread();
+		try {
+			// the second display realizes the font before the main display has one to reuse
+			Font fontOnSecondDisplay = secondDisplay.syncCall(() -> fontRegistry.get("myfont"));
+			assertEquals(secondDisplay, fontOnSecondDisplay.getDevice(),
+					"nothing to reuse yet, so the second display must realize a font of its own");
+
+			// the main display realizing the same font afterwards must not change what
+			// the second display gets, or it would silently switch instances mid-flight
+			fontRegistry.get("myfont");
+
+			Font fontOnSecondDisplayAgain = secondDisplay.syncCall(() -> fontRegistry.get("myfont"));
+			assertSame(fontOnSecondDisplay, fontOnSecondDisplayAgain,
+					"a display that realized a font itself must keep getting that same instance");
+		} finally {
+			secondDisplay.syncExec(secondDisplay::dispose);
+		}
+	}
+
 	@Test
 	public void put_invalidatesCachedFont_onAllDisplays() {
 		assumeTrue(OS.isWindows(), "multiple Display instance only allowed on Windows");
@@ -160,6 +255,9 @@ private static void testMultipleDisplayDispose(Supplier<Font> fontSupplier) {
 		assumeTrue(OS.isWindows(), "multiple Display instance only allowed on Windows");
 
 		Display secondDisplay = initializeDisplayInSeparateThread();
+		// the second display is asked first on purpose: the requested font is not
+		// realized on the main display yet, so there is nothing to reuse and the
+		// second display has to realize (and own) a font of its own
 		Font fontOnSecondDisplay = secondDisplay.syncCall(fontSupplier::get);
 
 		Font fontOnThisDisplayBeforeSecondDisplayDispose = fontSupplier.get();