You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@lucene.apache.org by us...@apache.org on 2022/08/25 16:17:53 UTC

[lucene] branch branch_9x updated: Fix classloading deadlock in analysis factories / AnalysisSPILoader initialization. This closes #11701 (#11718)

This is an automated email from the ASF dual-hosted git repository.

uschindler pushed a commit to branch branch_9x
in repository https://gitbox.apache.org/repos/asf/lucene.git


The following commit(s) were added to refs/heads/branch_9x by this push:
     new 61a8fd6172b Fix classloading deadlock in analysis factories / AnalysisSPILoader initialization. This closes #11701 (#11718)
61a8fd6172b is described below

commit 61a8fd6172bce7c08133b7803c1e1cbad51dd865
Author: Uwe Schindler <us...@apache.org>
AuthorDate: Thu Aug 25 18:16:04 2022 +0200

    Fix classloading deadlock in analysis factories / AnalysisSPILoader initialization. This closes #11701 (#11718)
---
 lucene/CHANGES.txt                                 |  3 +++
 .../apache/lucene/analysis/CharFilterFactory.java  | 29 +++++++++++++++++-----
 .../apache/lucene/analysis/TokenFilterFactory.java | 29 +++++++++++++++++-----
 .../apache/lucene/analysis/TokenizerFactory.java   | 29 +++++++++++++++++-----
 4 files changed, 72 insertions(+), 18 deletions(-)

diff --git a/lucene/CHANGES.txt b/lucene/CHANGES.txt
index 3456a9cac97..55f295a4269 100644
--- a/lucene/CHANGES.txt
+++ b/lucene/CHANGES.txt
@@ -49,6 +49,9 @@ Bug Fixes
 
 * LUCENE-10644: Facets#getAllChildren testing should ignore child order. (Yuting Gan)
 
+* LUCENE-10665, GITHUB#11701: Fix classloading deadlock in analysis factories / AnalysisSPILoader
+  initialization.  (Uwe Schindler)
+
 Build
 ---------------------
 
diff --git a/lucene/core/src/java/org/apache/lucene/analysis/CharFilterFactory.java b/lucene/core/src/java/org/apache/lucene/analysis/CharFilterFactory.java
index 3dddd0dde07..a03bd09a097 100644
--- a/lucene/core/src/java/org/apache/lucene/analysis/CharFilterFactory.java
+++ b/lucene/core/src/java/org/apache/lucene/analysis/CharFilterFactory.java
@@ -27,22 +27,39 @@ import java.util.Set;
  */
 public abstract class CharFilterFactory extends AbstractAnalysisFactory {
 
-  private static final AnalysisSPILoader<CharFilterFactory> loader =
-      new AnalysisSPILoader<>(CharFilterFactory.class);
+  /**
+   * This static holder class prevents classloading deadlock by delaying init of factories until
+   * needed.
+   */
+  private static final class Holder {
+    private static final AnalysisSPILoader<CharFilterFactory> LOADER =
+        new AnalysisSPILoader<>(CharFilterFactory.class);
+
+    private Holder() {}
+
+    static AnalysisSPILoader<CharFilterFactory> getLoader() {
+      if (LOADER == null) {
+        throw new IllegalStateException(
+            "You tried to lookup a CharFilterFactory by name before all factories could be initialized. "
+                + "This likely happens if you call CharFilterFactory#forName from a CharFilterFactory's ctor.");
+      }
+      return LOADER;
+    }
+  }
 
   /** looks up a charfilter by name from context classpath */
   public static CharFilterFactory forName(String name, Map<String, String> args) {
-    return loader.newInstance(name, args);
+    return Holder.getLoader().newInstance(name, args);
   }
 
   /** looks up a charfilter class by name from context classpath */
   public static Class<? extends CharFilterFactory> lookupClass(String name) {
-    return loader.lookupClass(name);
+    return Holder.getLoader().lookupClass(name);
   }
 
   /** returns a list of all available charfilter names */
   public static Set<String> availableCharFilters() {
-    return loader.availableServices();
+    return Holder.getLoader().availableServices();
   }
 
   /** looks up a SPI name for the specified char filter factory */
@@ -65,7 +82,7 @@ public abstract class CharFilterFactory extends AbstractAnalysisFactory {
    * given classpath/classloader!</em>
    */
   public static void reloadCharFilters(ClassLoader classloader) {
-    loader.reload(classloader);
+    Holder.getLoader().reload(classloader);
   }
 
   /** Default ctor for compatibility with SPI */
diff --git a/lucene/core/src/java/org/apache/lucene/analysis/TokenFilterFactory.java b/lucene/core/src/java/org/apache/lucene/analysis/TokenFilterFactory.java
index 57cbbfee9ab..9f692302baa 100644
--- a/lucene/core/src/java/org/apache/lucene/analysis/TokenFilterFactory.java
+++ b/lucene/core/src/java/org/apache/lucene/analysis/TokenFilterFactory.java
@@ -27,22 +27,39 @@ import java.util.Set;
  */
 public abstract class TokenFilterFactory extends AbstractAnalysisFactory {
 
-  private static final AnalysisSPILoader<TokenFilterFactory> loader =
-      new AnalysisSPILoader<>(TokenFilterFactory.class);
+  /**
+   * This static holder class prevents classloading deadlock by delaying init of factories until
+   * needed.
+   */
+  private static final class Holder {
+    private static final AnalysisSPILoader<TokenFilterFactory> LOADER =
+        new AnalysisSPILoader<>(TokenFilterFactory.class);
+
+    private Holder() {}
+
+    static AnalysisSPILoader<TokenFilterFactory> getLoader() {
+      if (LOADER == null) {
+        throw new IllegalStateException(
+            "You tried to lookup a TokenFilterFactory by name before all factories could be initialized. "
+                + "This likely happens if you call TokenFilterFactory#forName from a TokenFilterFactory's ctor.");
+      }
+      return LOADER;
+    }
+  }
 
   /** looks up a tokenfilter by name from context classpath */
   public static TokenFilterFactory forName(String name, Map<String, String> args) {
-    return loader.newInstance(name, args);
+    return Holder.getLoader().newInstance(name, args);
   }
 
   /** looks up a tokenfilter class by name from context classpath */
   public static Class<? extends TokenFilterFactory> lookupClass(String name) {
-    return loader.lookupClass(name);
+    return Holder.getLoader().lookupClass(name);
   }
 
   /** returns a list of all available tokenfilter names from context classpath */
   public static Set<String> availableTokenFilters() {
-    return loader.availableServices();
+    return Holder.getLoader().availableServices();
   }
 
   /** looks up a SPI name for the specified token filter factory */
@@ -65,7 +82,7 @@ public abstract class TokenFilterFactory extends AbstractAnalysisFactory {
    * given classpath/classloader!</em>
    */
   public static void reloadTokenFilters(ClassLoader classloader) {
-    loader.reload(classloader);
+    Holder.getLoader().reload(classloader);
   }
 
   /** Default ctor for compatibility with SPI */
diff --git a/lucene/core/src/java/org/apache/lucene/analysis/TokenizerFactory.java b/lucene/core/src/java/org/apache/lucene/analysis/TokenizerFactory.java
index 30115a1cd36..7cfc7b38108 100644
--- a/lucene/core/src/java/org/apache/lucene/analysis/TokenizerFactory.java
+++ b/lucene/core/src/java/org/apache/lucene/analysis/TokenizerFactory.java
@@ -27,22 +27,39 @@ import org.apache.lucene.util.AttributeFactory;
  */
 public abstract class TokenizerFactory extends AbstractAnalysisFactory {
 
-  private static final AnalysisSPILoader<TokenizerFactory> loader =
-      new AnalysisSPILoader<>(TokenizerFactory.class);
+  /**
+   * This static holder class prevents classloading deadlock by delaying init of factories until
+   * needed.
+   */
+  private static final class Holder {
+    private static final AnalysisSPILoader<TokenizerFactory> LOADER =
+        new AnalysisSPILoader<>(TokenizerFactory.class);
+
+    private Holder() {}
+
+    static AnalysisSPILoader<TokenizerFactory> getLoader() {
+      if (LOADER == null) {
+        throw new IllegalStateException(
+            "You tried to lookup a TokenizerFactory by name before all factories could be initialized. "
+                + "This likely happens if you call TokenizerFactory#forName from a TokenizerFactory ctor.");
+      }
+      return LOADER;
+    }
+  }
 
   /** looks up a tokenizer by name from context classpath */
   public static TokenizerFactory forName(String name, Map<String, String> args) {
-    return loader.newInstance(name, args);
+    return Holder.getLoader().newInstance(name, args);
   }
 
   /** looks up a tokenizer class by name from context classpath */
   public static Class<? extends TokenizerFactory> lookupClass(String name) {
-    return loader.lookupClass(name);
+    return Holder.getLoader().lookupClass(name);
   }
 
   /** returns a list of all available tokenizer names from context classpath */
   public static Set<String> availableTokenizers() {
-    return loader.availableServices();
+    return Holder.getLoader().availableServices();
   }
 
   /** looks up a SPI name for the specified tokenizer factory */
@@ -65,7 +82,7 @@ public abstract class TokenizerFactory extends AbstractAnalysisFactory {
    * given classpath/classloader!</em>
    */
   public static void reloadTokenizers(ClassLoader classloader) {
-    loader.reload(classloader);
+    Holder.getLoader().reload(classloader);
   }
 
   /** Default ctor for compatibility with SPI */