计算机编程中，最佳实践是许多开发人员遵循的一组非正式规则，以提高软件质量、可读性和可维护性。在应用程序长时间保持使用的情况下，最佳实践尤其有益，这样它最初是由一个团队开发的，然后由不同的人组成的维护团队进行维护。

本教程将提供Java最佳实践的概述，以及每个条目的解释，包括Java编程的顶级最佳实践列表中的每一项。

Java编程最佳实践概览

虽然Java最佳实践的完整列表可能很长，但对于那些正在努力提高代码质量的编码人员来说，有几个被认为是一个很好的起点，包括使用适当的命名规范、使类成员私有化、避免使用空的catch块、避免内存泄漏以及正确地注释代码块：

• 使用适当的命名规范
• 将类成员设置为私有
• 在长数字文字中使用下划线
• 避免空的catch块
• 使用StringBuilder或StringBuffer进行字符串连接
• 避免冗余初始化
• 使用增强型for循环代替带计数器的for循环
• 正确处理空指针异常
• Float或Double：哪一个是正确的选择？
• 使用单引号和双引号
• 避免内存泄漏
• 返回空集合而不是返回Null元素
• 高效使用字符串
• 避免创建不必要的对象
• 正确注释代码

Java中的类成员应该是私有的

在Java中，类的成员越不可访问，越好！第一步是使用private访问修饰符。目标是促进理想的封装，这是面向对象编程（OOP）的基本概念之一。太多时候，新的开发人员没有正确地为类分配访问修饰符，或者倾向于将它们设置为public以使事情更容易。

考虑以下字段被设置为public的类：

public class BandMember {
  public String name;
  public String instrument;
}

在这里，类的封装性被破坏了，因为任何人都可以直接更改这些值，如下所示：

BandMember billy = new BandMember();
billy.name = "George";
billy.instrument = "drums";

使用private访问修饰符与类成员一起可以将字段隐藏起来，防止用户通过setter方法之外的方式更改数据：

public class BandMember {
  private String name;
  private String instrument;

  public void setName(String name) {
    this.name = name;
  }
  public void setInstrument(String instrument)
    this.instrument = instrument;
  }
}

在setter方法中也是放置验证代码和/或管理任务（如增加计数器）的理想位置。

在长数字文字中使用下划线

得益于Java 7的更新，开发人员现在可以在长数字字面量中使用下划线（_），以提高可读性。以下是在允许下划线之前一些长数字字面量的示例：

int minUploadSize = 05437326;
long debitBalance = 5000000000000000L;
float pi = 3.141592653589F;

我想您会同意下划线使值更易读：

int minUploadSize = 05_437_326;
long debitBalance = 5_000_000_000_000_000L;
float pi = 3.141_592_653_589F;

避免空的Catch块

在Java中，把catch块留空是非常不好的习惯，有两个原因：一是它可能导致程序默默地失败，二是程序可能会继续运行而不会发生任何异常。这两种结果都会使调试变得非常困难

考虑以下程序，它从命令行参数中计算两个数字的和：

public class Sum {
  public static void main(String[] args) {
    int a = 0;
    int b = 0;

    try {
      a = Integer.parseInt(args[0]);
      b = Integer.parseInt(args[1]);
    } catch (NumberFormatException ex) {
    }

    int sum = a + b;

    System.out.println(a + " + " + b + " = " + sum);
  }
}

Java的parseInt()方法会抛出NumberFormatException异常，需要开发人员在其调用周围使用try/catch块来捕获异常。不幸的是，这位开发人员选择忽略抛出的异常！因此，传入无效参数，例如“45y”，将导致关联的变量被赋为其类型的默认值，对于int类型来说是0。

通常，在捕获异常时，程序员应采取以下三个行动中的一个或多个：

1. 开发人员最起码应该通知用户异常情况，要么让他们重新输入无效的值，要么让他们知道程序必须提前终止。
2. 使用 JDK Logging 或 Log4J 记录异常日志。
3. 将异常封装并作为一个新的、更适合应用程序的异常重新抛出。

以下是重新编写后的Sum应用程序，用于通知用户输入无效并因此终止程序：

public class Sum {
  public static void main(String[] args) {
    int a = 0;
    int b = 0;

    try {
      a = Integer.parseInt(args[0]);
    } catch (NumberFormatException ex) {
      System.out.println(args[0] + " is not a number. Aborting...");
      return;
    }

    try {
      b = Integer.parseInt(args[1]);
    } catch (NumberFormatException ex) {
      System.out.println(args[1] + " is not a number. Aborting...");
      return;
    }

    int sum = a + b;

    System.out.println(a + " + " + b + " = " + sum);
  }
}

以下是我们观察到的结果：

使用StringBuilder或StringBuffer进行字符串拼接

“+” 运算符是在 Java 中快速和简便地组合字符串的方法。在 Hibernate 和 JPA 时代之前，对象是手动持久化的，通过从头开始构建 SQL INSERT 语句来实现！以下是一个存储一些用户数据的示例：

String sql = "Insert Into Users (name, age)";
       sql += " values ('" + user.getName();
       sql += "', '" + user.getage();
       sql += "')";

很遗憾，当像上面那样连接多个字符串时，Java编译器必须创建多个中间字符串对象，然后将它们合并成最终连接的字符串。

相反，我们应该使用StringBuilder或StringBuffer类。两者都包含函数，可以连接字符串而无需创建中间String对象，从而节省处理时间和不必要的内存使用。

以前的代码可以使用 StringBuilder 重写，如下所示：

StringBuilder sqlSb = new StringBuilder("Insert Into Users (name, age)");
sqlSb.append(" values ('").append(user.getName());
sqlSb.append("', '").append(user.getage());
sqlSb.append("')");
String sqlSb = sqlSb.toString();

这对开发者来说可能要费点事儿，但是这样做非常值得！

StringBuffer 与 StringBuilder

虽然StringBuffer和StringBuilder类都比“+”运算符更可取，但它们并不相同。StringBuilder比StringBuffer更快，但不是线程安全的。因此，在非多线程环境中进行字符串操作时，应使用StringBuilder；否则，请使用StringBuffer类。

避免冗余初始化

尽管某些语言如TypeScript强烈建议在声明时初始化变量，但在Java中并非总是必要的，因为它在声明时将默认初始化值（如0、false和null）分配给变量。

因此，Java的最佳实践是要知道成员变量的默认初始化值，除非您想将它们设置为除默认值以外的其他值，否则不要显式初始化变量。

以下是一个计算从1到1000的自然数之和的短程序。请注意，只有部分变量被初始化：

class VariableInitializationExample {
  public static void main(String[] args) {

    // automatically set to 0
    int sum;
    final numberOfIterations = 1000;

    // Set the loop counter to 1
    for (int i = 1; i &= numberOfIterations; ++i) {
      sum += i;
    }

    System.out.println("Sum = " + sum);
  }
}

使用增强型for循环代替需要计数器的for循环

尽管 for 循环在某些情况下很有用，但是计数器变量可能会引起错误。例如，计数器变量可能会在稍后的代码中被无意中更改。即使从 1 而不是从 0 开始索引，也可能导致意外行为。出于这些原因，for-each 循环（也称为增强型 for 循环）可能是更好的选择。

考虑以下代码：

String[] names = {"Rob", "John", "George", "Steve"};
for (int i = 0; i < names.length; i++) {
  System.out.println(names[i]);
}

在这里，变量i既是循环计数器，又是数组names的索引。尽管这个循环只是打印每个名称，但如果下面有修改i的代码，就会变得棘手。我们可以通过使用下面所示的for-each循环轻松避开整个问题：

for (String name : names) {
  System.out.println(name);
}

使用增强的for循环，出错的机会要少得多！

合理处理空指针异常

空指针异常在Java中是一个非常常见的问题，可能是由于其面向对象的设计所致。当您试图在 Null 对象引用上调用方法时，就会发生 Null Pointer 异常。这通常发生在在类实例化之前调用实例方法的情况下，如下例所示：

Office office;

// later in the code...
Employee[] employees = office.getEmployees();

虽然你无法完全消除 Null Pointer Exceptions，但有方法可以将其最小化。一种方法是在调用对象的方法之前检查对象是否为 Null。以下是使用三元运算符的示例：

Office office;

// later in the code...
Employee[] employees = office == null ? 0 : office.getEmployees();

你可能还想抛出自己的异常：

Office office;
Employee[] employees;

// later in the code...
if (office == null) {
  throw new CustomApplicationException("Office can't be null!");
} else {
  employees = office.getEmployees();
}

Float或Double：应该使用哪个？

浮点数和双精度数是相似的类型，因此许多开发人员不确定该选择哪种类型。两者都处理浮点数，但具有非常不同的特性。例如，float的大小为32位，而double分配了64位的内存空间，因此double可以处理比float大得多的小数。然后有一个精度问题：float只能容纳7位精度。极小的指数大小意味着一些位是不可避免的丢失的。相比之下，double为指数分配了更多的位数，允许它处理高达15位精度。

因此，当速度比准确性更重要时，通常建议使用float。尽管大多数程序不涉及大量计算，但在数学密集型应用中，精度差异可能非常显著。当需要的小数位数已知时，float也是一个不错的选择。当精度非常重要时，double应该是你的首选。只需记住，Java强制使用double作为处理浮点数的默认数据类型，因此您可能需要附加字母"f"来明确表示float，例如，1.2f。

单引号和双引号在字符串连接中的使用

在Java中，双引号（“）用于保存字符串，单引号用于字符（由char类型表示）。当我们尝试使用+连接运算符连接字符时，可能会出现问题。问题在于使用+连接字符会将char的值转换为ascii，从而产生数字输出。以下是一些示例代码，以说明这一点：

char a, b, c;
a = 'a';
b = 'b';
c = 'c';

str = a + b + c; // not "abc", but 294!

就像字符串连接最好使用StringBuilder或StringBuffer类一样，字符连接也是如此！在上面的代码中，变量a、b和c可以通过以下方式组合成一个字符串：

new StringBuilder().append(a).append(b).append(c).toString()

我们可以在下面观察到期望的结果：

避免Java中的内存泄漏

在Java中，开发人员并没有太多关于内存管理的控制权，因为Java通过垃圾回收自动地进行内存管理。尽管如此，有一些Java最佳实践可以帮助开发人员避免内存泄漏，例如：

• 避免创建不必要的对象。
• 避免使用"+"运算符进行字符串连接。
• 避免在会话中存储大量数据。
• 在会话不再使用时，及时让会话超时。
• 避免使用静态对象，因为它们在整个应用程序的生命周期内存在。
• 在与数据库交互时，不要忘记在finally块中关闭ResultSet、Statements和Connection对象。

返回空集合而不是null引用。

你知道吗，null引用经常被称为软件开发中最严重的错误吗？1965年，Tony Hoare在设计面向对象语言（OOP）的引用的第一个全面类型系统时发明了null引用。后来在2009年的一次会议上，Hoare为自己的发明道歉，承认他的创造“导致了无数的错误、漏洞和系统崩溃，在过去四十年中可能造成了数十亿美元的痛苦和损失。”

在Java中，通常最好返回空值而不是null，特别是当返回集合、可枚举对象或对象时更为重要。尽管你自己的代码可能会处理返回的null值，但其他开发人员可能会忘记编写空值检查，甚至没有意识到null是可能的返回值！

以下是一些Java代码，它以ArrayList的形式获取库存中的书籍列表。但是，如果列表为空，则返回一个空列表：

private final List<Book> booksInStock = ...

public List<Book> getInStockBooks() {
  return booksInStock.isEmpty() ? Collections.emptyList() : new ArrayList<>(booksInStock);
}

这使得方法的调用者可以在不必首先检查null引用的情况下迭代列表：

(Book book: getInStockBooks()) {
 // do something with books
}

Java 中字符串的高效使用

我们已经讨论了使用 + 连接操作符可能产生的副作用，但还有其他一些方法可以更有效地使用字符串，以避免浪费内存和处理器周期。例如，在实例化 String 对象时，通常最好直接创建 String 而不是使用构造函数。原因是什么？使用直接创建 String 比使用构造函数更快（更不用说更少的代码！）。

这里是在Java中创建字符串的两种等效方式：直接创建和使用构造函数：

// directly
String str = "abc";
// using a constructor
char data[] = {'a', 'b', 'c'};
String str = new String(data);

虽然两种方法都是等效的，但直接创建字符串的方式更好。

Java中不必要的对象创建

你知道吗？在Java中，对象的创建是消耗内存最多的操作之一。因此，在没有充分理由的情况下，最好避免创建对象，并仅在绝对必要时才这样做。

那么，如何将这个实践起来呢？具有讽刺意味的是，像我们上面看到的直接创建字符串就是避免不必要创建对象的一种方式！

以下是一个更复杂的示例：

以下是一个Person类的例子，它包括一个isBabyBoomer()方法，用于判断此人是否属于“婴儿潮”年龄段，出生于1946年至1964年之间：

public class Person {
  private final Date birthDate;

  public boolean isBabyBoomer() {
    // Unnecessary allocation of expensive object!
    Calendar gmtCal =
        Calendar.getInstance(TimeZone.getTimeZone("GMT"));
    gmtCal.set(1946, Calendar.JANUARY, 1, 0, 0, 0);
    Date boomStart = gmtCal.getTime();
    gmtCal.set(1965, Calendar.JANUARY, 1, 0, 0, 0);
    Date boomEnd = gmtCal.getTime();

    return birthDate.compareTo(boomStart) >= 0 &&
           birthDate.compareTo(boomEnd)   <  0;
  }
}

isBabyBoomer()方法每次被调用都会创建一个新的Calendar、TimeZone和两个Date实例，这是不必要的。纠正这种低效的方法之一是使用静态初始化器，以便只在初始化时创建Calendar、TimeZone和Date对象，而不是每次调用isBabyBoomer()方法。

class Person {
  private final Date birthDate;

  // The starting and ending dates of the baby boom.
  private static final Date BOOM_START;
  private static final Date BOOM_END;

  static {
    Calendar gmtCal =
      Calendar.getInstance(TimeZone.getTimeZone("GMT"));
    gmtCal.set(1946, Calendar.JANUARY, 1, 0, 0, 0);
    BOOM_START = gmtCal.getTime();
    gmtCal.set(1965, Calendar.JANUARY, 1, 0, 0, 0);
    BOOM_END = gmtCal.getTime();
  }

  public boolean isBabyBoomer() {
    return birthDate.compareTo(BOOM_START) >= 0 &&
       birthDate.compareTo(BOOM_END)       <  0;
  }
}

Java中适当的注释

清晰简洁的注释在阅读其他开发人员的代码时非常有用。以下是写出高质量注释的几个指南：

1. 注释不应该重复代码。
2. 好的注释不能弥补代码不清晰的问题。
3. 如果您无法编写清晰的注释，则代码可能存在问题。
4. 在注释中解释不符合惯用方式的代码。
5. 在最有用的地方包含指向外部参考文献的链接。
6. 在修复错误时添加注释。
7. 使用注释标记未完成的实现，通常使用标记“TODO:”开头。

总结

在本文中，我们了解了15个Java最佳实践，并探讨了类成员封装、在冗长的数字字面值中使用下划线、避免空catch块、正确完成字符串连接、如何避免冗余初始化以及使用增强的for循环。

【注】本文译自： Java Best Practices | Developer.com

Synchronized曾经是一个革命性的技术，在当前仍然有重要的用途。但是，现在是时候转向更新的Java线程原语，同时重新考虑我们的核心逻辑。

自从Java第一个测试版以来，我就一直在使用它。从那时起，线程就是我最喜欢的特性之一。Java是第一种在编程语言本身中引入线程支持的语言。那是一个具有争议的决定。在过去的十年中，每种编程语言都竞相引入async/await，甚至Java也有一些第三方支持……但是Java选择了引入更优越的虚拟线程（Loom项目）。本文并不讨论这个问题。

我觉得这很好，证明了Java的核心实力。Java不仅仅是一种语言，还是一种文化。这种文化注重深思熟虑的变革，而不是盲目跟随时尚潮流。

在本文中，我想重新探讨Java中的线程编程旧方法。我习惯使用synchronized、wait、notify等技术。但是， “然而，这些方法已经不再是Java中线程处理的最佳方式。 我也是问题的一部分。我还是习惯于使用这些技术，发现很难适应自Java 5以来就存在的一些API。这是一种习惯的力量。 虽然可以讨论许多处理线程的出色API，但我想在这里专注讨论锁，因为它们是基础但极为重要的。

Synchronized 与 ReentrantLock

我犹豫放弃使用 synchronized 的原因是，并没有更好的替代方案。现在弃用 synchronized 的主要原因是，它可能会在 Loom 中触发线程固定，这并不理想。JDK 21 可能会修复这个问题（当 Loom 正式发布时），但还有一些理由弃用它。

synchronized 的直接替代品是 ReentrantLock。不幸的是，ReentrantLock 相比 synchronized 很少有优势，因此迁移的好处最多是存疑的。事实上，它有一个主要的缺点。为了了解这一点，让我们看一个例子。下面是我们如何使用 synchronized：

synchronized(LOCK) {
    // safe code
}

LOCK.lock();
try {
    // safe code
} finally {
    LOCK.unlock();
}

ReentrantLock 的第一个缺点是冗长。我们需要try块，因为如果在块内部发生异常，锁将保持。而 synchronized 则会自动处理异常。

有些人会使用 AutoClosable 对锁进行封装，大概是这样的：

public class ClosableLock implements AutoCloseable {
   private final ReentrantLock lock;

   public ClosableLock() {
       this.lock = new ReentrantLock();
   }

   public ClosableLock(boolean fair) {
       this.lock = new ReentrantLock(fair);
   }

   @Override
   public void close() throws Exception {
       lock.unlock();
   }

   public ClosableLock lock() {
       lock.lock();
       return this;
   }

   public ClosableLock lockInterruptibly() throws InterruptedException {
       lock.lock();
       return this;
   }

   public void unlock() {
       lock.unlock();
   }
}

注意，我没有实现 Lock 接口，这本来是最理想的。这是因为 lock 方法返回了可自动关闭的实现，而不是 void。

一旦我们这样做了，我们就可以编写更简洁的代码，比如这样：

try(LOCK.lock()) {
 // safe code
}

我喜欢代码更简洁的写法，但是这个方法存在一些问题，因为 try-with-resource 语句是用于清理资源的，而我们正在重复使用锁对象。虽然调用了 close 方法，但是我们会再次在同一个对象上调用它。我认为，将 try-with-resource 语法扩展到支持锁接口可能是个好主意。但在此之前，这个技巧可能不值得采用。

ReentrantLock 的优势

使用ReentrantLock的最大原因是Loom支持。其他的优点也不错，但没有一个是“杀手级功能”。

我们可以在方法之间使用它，而不是在一个连续的代码块中使用。但是这可能不是一个好主意，因为你希望尽量减少锁定区域，并且失败可能会成为一个问题。我不认为这个特性是一个优点。

ReentrantLock提供了公平锁（fairness）的选项。这意味着它会先服务于最先停在锁上的线程。我试图想到一个现实而简单的使用案例，但却无从下手。如果您正在编写一个复杂的调度程序，并且有许多线程不断地排队等待资源，您可能会发现一个线程由于其他线程不断到来而被“饥饿”。但是，这种情况可能更适合使用并发包中的其他选项。也许我漏掉了什么……

lockInterruptibly() 方法允许我们在线程等待锁时中断它。这是一个有趣的特性，但是很难找到一个真正实际应用场景。如果你编写的代码需要非常快速响应中断，你需要使用 lockInterruptibly() API 来获得这种能力。但是，你通常在 lock()方法内部花费多长时间呢？

这种情况可能只在极端情况下才会有影响，大多数人在编写高级多线程代码时可能不会遇到这种情况。

ReadWriteReentrantLock

更好的方法是使用ReadWriteReentrantLock。大多数资源都遵循频繁读取、少量写入的原则。由于读取变量是线程安全的，除非正在写入变量，否则没有必要加锁。这意味着我们可以将读取操作进行极致优化，同时稍微降低写操作的速度。

假设这是你的使用情况，你可以创建更快的代码。使用读写锁时，我们有两个锁，一个读锁，如下图所示。它允许多个线程通过，实际上是“自由竞争”的。

一旦我们需要写入变量，我们需要获得写锁，如下图所示。我们尝试请求写锁，但仍有线程从变量中读取，因此我们必须等待。

一旦所有线程完成读取，所有读取操作都会阻塞，写入操作只能由一个线程执行，如下图所示。一旦释放写锁，我们将回到第一张图中的“自由竞争”状态。

这是一种强大的模式，我们可以利用它使集合变得更快。一个典型的同步列表非常慢。它同步所有的操作，包括读和写。我们有一个CopyOnWriteArrayList，它对于读取操作非常快，但是任何写入操作都很慢。

如果可以避免从方法中返回迭代器，你可以封装列表操作并使用这个API。例如，在以下代码中，我们将名字列表暴露为只读，但是当需要添加名字时，我们使用写锁。这可以轻松超过synchronized列表的性能：

private final ReadWriteLock LOCK = new ReentrantReadWriteLock();
private Collection<String> listOfNames = new ArrayList<>();
public void addName(String name) {
   LOCK.writeLock().lock();
   try {
       listOfNames.add(name);
   } finally {
       LOCK.writeLock().unlock();
   }
}
public boolean isInList(String name) {
   LOCK.readLock().lock();
   try {
       return listOfNames.contains(name);
   } finally {
       LOCK.readLock().unlock();
   }
}

这个方案可行，因为synchronized是可重入的。我们已经持有锁，所以从methodA()进入methodB()不会阻塞。这在使用ReentrantLock时也同样适用，只要我们使用相同的锁或相同的synchronized对象。

StampedLock返回一个戳记（stamp），我们用它来释放锁。因此，它有一些限制，但它仍然非常快和强大。它也包括一个读写戳记，我们可以用它来保护共享资源。但ReadWriteReentrantLock不同的是，它允许我们升级锁。为什么需要这样做呢？

看一下之前的addName()方法…如果我用"Shai"两次调用它会怎样？

是的，我可以使用Set…但是为了这个练习的目的，让我们假设我们需要一个列表…我可以使用ReadWriteReentrantLock编写那个逻辑：

public void addName(String name) {
   LOCK.writeLock().lock();
   try {
       if(!listOfNames.contains(name)) {
           listOfNames.add(name);
       }
   } finally {
       LOCK.writeLock().unlock();
   }
}

这很糟糕。我“付出”写锁只是为了在某些情况下检查contains()（假设有很多重复项）。我们可以在获取写锁之前调用isInList(name)。然后我们会：

• 获取读锁
• 释放读锁
• 获取写锁
• 释放写锁

在两种情况下，我们可能会排队, 这样可能会增加额外的麻烦，不一定值得。

有了StampedLock，我们可以将读锁更新为写锁，并在需要的情况下立即进行更改，例如：

public void addName(String name) {
   long stamp = LOCK.readLock();
   try {
       if(!listOfNames.contains(name)) {
           long writeLock = LOCK.tryConvertToWriteLock(stamp);
           if(writeLock == 0) {
               throw new IllegalStateException();
           }
           listOfNames.add(name);
       }
   } finally {
       LOCK.unlock(stamp);
   }
}

这是针对这些情况的一个强大的优化。

终论

我经常不假思索地使用 synchronized 集合，这有时可能是合理的，但对于大多数情况来说，这可能是次优的。通过花费一点时间研究与线程相关的原语，我们可以显著提高性能。特别是在处理 Loom 时，其中底层争用更为敏感。想象一下在 100 万并发线程上扩展读取操作的情况…在这些情况下，减少锁争用的重要性要大得多。

你可能会想，为什么 synchronized 集合不能使用 ReadWriteReentrantLock 或者是 StampedLock 呢？

这是一个问题，因为API的可见接口范围非常大，很难针对通用用例进行优化。这就是控制低级原语的地方，可以使高吞吐量和阻塞代码之间的差异。

【注】本文译自： Relearning Java Thread Primitives – DZone

1. 关键的Java JVM选项和参数

让我们来看看在Java环境中可以配置的21个最重要的JVM选项和参数。

1. -Xms：将设置JVM的初始堆大小。
2. -Xmx：将设置JVM的最大堆大小。
3. -Xss：将设置每个线程的内部使用的线程堆栈的大小。
4. -XX：+UseCompressedOops：启用使用压缩对象指针以减少内存使用的功能。
5. -XX：+UseThreadPriorities：将指示JVM使用本机线程优先级。
6. -XX：PermSize：将设置垃圾收集器永久生成空间的初始大小。
7. -XX：MaxPermSize：将设置垃圾收集器永久生成空间的最大大小。
8. -XX：NewSize：设置年轻代空间的初始大小。
9. -XX：MaxNewSize：设置年轻代空间的最大大小。
10. -XX：SurvivorRatio：设置伊甸园空间与幸存者空间的比例。
11. -XX：MaxTenuringThreshold：设置幸存者空间中对象的最大年龄。
12. -XX：+UseParNewGC：指示JVM使用新的并行生成垃圾收集器。
13. -XX：+UseSerialGC：指示JVM使用串行垃圾收集器。
14. -XX：+UseG1GC：指示JVM使用Garbage First（G1）垃圾收集器。
15. -XX：+UseZGC：指示JVM使用ZGC垃圾收集器。
16. -XX：+HeapDumpOnOutOfMemoryError：告诉JVM在发生OutOfMemoryError时创建堆转储文件。
17. -XX：HeapDumpPath：为JVM提供自定义路径，在堆转储期间写入堆的内容。
18. -Djava.library.path：允许您指定在运行时需要的本机库的路径。
19. -Duser.timezone：允许您为JVM设置自定义时区。
20. -XX：+PrintGCDetails：指示JVM打印详细的垃圾回收日志，以帮助您进行GC优化。
21. -XX：+PrintFlagsFinal-version：将打印在JVM上设置的所有当前配置的标志和选项。

2. 如何使用Java JVM选项

所有这些JVM选项都可以通过将它们作为文本附加到Java运行时命令后来简单地使用。

例如，以下命令将使用六个不同的参数运行名为Go的应用程序，以优化内存分配和垃圾回收：

java Go -XX:MaxPermSize=128m -XX:MaxNewSize=256m -Xms768m -Xmx768m -XX:SurvivorRatio=128 -XX:MaxTenuringThreshold=0

Java JVM选项可用于管理内存和优化GC性能

3. 最常用的JVM参数

在列举的所有 JVM 选项中，最常用的是 Xms 和 Xmx，分别设置最小堆大小和最大堆大小。

下面的示例将最小堆大小设置为 768 MB，最大堆大小设置为 2 GB。

-Xms768m
-Xmx2048

4. GC 选择 JVM 选项

Java的一个优点是它为开发者执行垃圾回收，这使得应用程序更加健壮，更不容易发生内存泄漏问题。

有许多垃圾回收器可用，具有各种暂停行为和停顿时间。

在启动运行时，您只能使用以下 Java JVM 选项之一选择一个垃圾收集器：

-XX:+UseSerialGC
-XX:+UseParallelGC
-XX:+USeParNewGC
-XX:+UseG1GC
-XX:+UseZGC

5. 垃圾回收调优选项

VM实现了一种分代垃圾回收算法，它积极监控新对象，而很少检查旧对象。JVM管理eden空间、tenured空间甚至PermGen空间的方式可以通过JVM选项进行配置，如下：

-XX:MaxPermSize
-XX:PermSize
-XX:NewSize
-XX:MaxNewSize
-XX:SurvivorRatio
-XX:MaxTenuringThreshold

6. 用于检查的JVM打印选项

JVM还提供了一些打印方法，允许您查看Java运行时的状态。有用的JVM打印选项包括：

-XX:+PrintGCDetails
-XX:+PrintGCDateStamps
-XX:+PrintHeapAtGC
-XX:+PrintCommandLineFlags
-XX:+PrintFlagsFinal

PrintFlagsFinal是一项有趣的JVM选项，它将显示所有JVM标志设置的详细信息，输出内容有超过500行。本文介绍的Java JVM选项已经全部讲解完毕，如果你对PrintFlagsFinal JVM标志的详细输出感兴趣，可以查看上文提到的输出内容。

$ java -XX:+PrintFlagsFinal -version
[Global flags]
int ActiveProcessorCount = -1
uintx AdaptiveSizeDecrementScaleFactor = 4
uintx AdaptiveSizeMajorGCDecayTimeScale = 10
uintx AdaptiveSizePolicyCollectionCostMargin = 50
uintx AdaptiveSizePolicyInitializingSteps = 20
uintx AdaptiveSizePolicyOutputInterval = 0
uintx AdaptiveSizePolicyWeight = 10
uintx AdaptiveSizeThroughPutPolicy = 0
uintx AdaptiveTimeWeight = 25
bool AggressiveHeap = false
intx AliasLevel = 3
bool AlignVector = false
ccstr AllocateHeapAt =
intx AllocateInstancePrefetchLines = 1
intx AllocatePrefetchDistance = 256
intx AllocatePrefetchInstr = 0
intx AllocatePrefetchLines = 3
intx AllocatePrefetchStepSize = 64
intx AllocatePrefetchStyle = 1
bool AllowParallelDefineClass = false
bool AllowRedefinitionToAddDeleteMethods = false
bool AllowUserSignalHandlers = false
bool AllowVectorizeOnDemand = true
bool AlwaysActAsServerClassMachine = false
bool AlwaysCompileLoopMethods = false
bool AlwaysLockClassLoader = false
bool AlwaysPreTouch = false
bool AlwaysRestoreFPU = false
bool AlwaysTenure = false
ccstr ArchiveClassesAtExit =
intx ArrayCopyLoadStoreMaxElem = 8
size_t AsyncLogBufferSize = 2097152
intx AutoBoxCacheMax = 128
intx BCEATraceLevel = 0
bool BackgroundCompilation = true
size_t BaseFootPrintEstimate = 268435456
intx BiasedLockingBulkRebiasThreshold = 20
intx BiasedLockingBulkRevokeThreshold = 40
intx BiasedLockingDecayTime = 25000
intx BiasedLockingStartupDelay = 0
bool BlockLayoutByFrequency = true
intx BlockLayoutMinDiamondPercentage = 20
bool BlockLayoutRotateLoops = true
intx C1InlineStackLimit = 5
intx C1MaxInlineLevel = 9
intx C1MaxInlineSize = 35
intx C1MaxRecursiveInlineLevel = 1
intx C1MaxTrivialSize = 6
bool C1OptimizeVirtualCallProfiling = true
bool C1ProfileBranches = true
bool C1ProfileCalls = true
bool C1ProfileCheckcasts = true
bool C1ProfileInlinedCalls = true
bool C1ProfileVirtualCalls = true
bool C1UpdateMethodData = true
intx CICompilerCount = 4
bool CICompilerCountPerCPU = true
bool CITime = false
bool CheckJNICalls = false
bool ClassUnloading = true
bool ClassUnloadingWithConcurrentMark = true
bool ClipInlining = true
uintx CodeCacheExpansionSize = 65536
bool CompactStrings = true
ccstr CompilationMode = default
ccstrlist CompileCommand =
ccstr CompileCommandFile =
ccstrlist CompileOnly =
intx CompileThreshold = 10000
double CompileThresholdScaling = 1.000000
intx CompilerThreadPriority = -1
intx CompilerThreadStackSize = 0
size_t CompressedClassSpaceSize = 1073741824
uint ConcGCThreads = 3
intx ConditionalMoveLimit = 3
intx ContendedPaddingWidth = 128
bool CrashOnOutOfMemoryError = false
bool CreateCoredumpOnCrash = true
bool CriticalJNINatives = false
bool DTraceAllocProbes = false
bool DTraceMethodProbes = false
bool DTraceMonitorProbes = false
bool DisableAttachMechanism = false
bool DisableExplicitGC = false
bool DisplayVMOutputToStderr = false
bool DisplayVMOutputToStdout = false
bool DoEscapeAnalysis = true
bool DoReserveCopyInSuperWord = true
bool DontCompileHugeMethods = true
bool DontYieldALot = false
ccstr DumpLoadedClassList =
bool DumpReplayDataOnError = true
bool DumpSharedSpaces = false
bool DynamicDumpSharedSpaces = false
bool EagerXrunInit = false
intx EliminateAllocationArraySizeLimit = 64
bool EliminateAllocations = true
bool EliminateAutoBox = true
bool EliminateLocks = true
bool EliminateNestedLocks = true
bool EnableContended = true
bool EnableDynamicAgentLoading = true
size_t ErgoHeapSizeLimit = 0
ccstr ErrorFile =
bool ErrorFileToStderr = false
bool ErrorFileToStdout = false
uint64_t ErrorLogTimeout = 120
double EscapeAnalysisTimeout = 20.000000
bool EstimateArgEscape = true
bool ExecutingUnitTests = false
bool ExitOnOutOfMemoryError = false
bool ExplicitGCInvokesConcurrent = false
bool ExtendedDTraceProbes = false
bool ExtensiveErrorReports = false
ccstr ExtraSharedClassListFile =
bool FilterSpuriousWakeups = true
bool FlightRecorder = false
ccstr FlightRecorderOptions =
bool ForceTimeHighResolution = false
intx FreqInlineSize = 325
double G1ConcMarkStepDurationMillis = 10.000000
uintx G1ConcRSHotCardLimit = 4
size_t G1ConcRSLogCacheSize = 10
size_t G1ConcRefinementGreenZone = 0
size_t G1ConcRefinementRedZone = 0
uintx G1ConcRefinementServiceIntervalMillis = 300
uint G1ConcRefinementThreads = 10
size_t G1ConcRefinementThresholdStep = 2
size_t G1ConcRefinementYellowZone = 0
uintx G1ConfidencePercent = 50
size_t G1HeapRegionSize = 2097152
uintx G1HeapWastePercent = 5
uintx G1MixedGCCountTarget = 8
uintx G1PeriodicGCInterval = 0
bool G1PeriodicGCInvokesConcurrent = true
double G1PeriodicGCSystemLoadThreshold = 0.000000
intx G1RSetRegionEntries = 512
intx G1RSetSparseRegionEntries = 16
intx G1RSetUpdatingPauseTimePercent = 10
uint G1RefProcDrainInterval = 1000
uintx G1ReservePercent = 10
uintx G1SATBBufferEnqueueingThresholdPercent = 60
size_t G1SATBBufferSize = 1024
size_t G1UpdateBufferSize = 256
bool G1UseAdaptiveConcRefinement = true
bool G1UseAdaptiveIHOP = true
uintx GCDrainStackTargetSize = 64
uintx GCHeapFreeLimit = 2
uintx GCLockerEdenExpansionPercent = 5
uintx GCPauseIntervalMillis = 201
uintx GCTimeLimit = 98
uintx GCTimeRatio = 12
size_t HeapBaseMinAddress = 2147483648
bool HeapDumpAfterFullGC = false
bool HeapDumpBeforeFullGC = false
intx HeapDumpGzipLevel = 0
bool HeapDumpOnOutOfMemoryError = false
ccstr HeapDumpPath =
uintx HeapFirstMaximumCompactionCount = 3
uintx HeapMaximumCompactionInterval = 20
uintx HeapSearchSteps = 3
size_t HeapSizePerGCThread = 43620760
bool IgnoreEmptyClassPaths = false
bool IgnoreUnrecognizedVMOptions = false
uintx IncreaseFirstTierCompileThresholdAt = 50
bool IncrementalInline = true
uintx InitialCodeCacheSize = 2555904
size_t InitialHeapSize = 268435456
uintx InitialRAMFraction = 64
double InitialRAMPercentage = 1.562500
uintx InitialSurvivorRatio = 8
uintx InitialTenuringThreshold = 7
uintx InitiatingHeapOccupancyPercent = 45
bool Inline = true
ccstr InlineDataFile =
intx InlineSmallCode = 2500
bool InlineSynchronizedMethods = true
intx InteriorEntryAlignment = 16
intx InterpreterProfilePercentage = 33
bool JavaMonitorsInStackTrace = true
intx JavaPriority10_To_OSPriority = -1
intx JavaPriority1_To_OSPriority = -1
intx JavaPriority2_To_OSPriority = -1
intx JavaPriority3_To_OSPriority = -1
intx JavaPriority4_To_OSPriority = -1
intx JavaPriority5_To_OSPriority = -1
intx JavaPriority6_To_OSPriority = -1
intx JavaPriority7_To_OSPriority = -1
intx JavaPriority8_To_OSPriority = -1
intx JavaPriority9_To_OSPriority = -1
size_t LargePageHeapSizeThreshold = 134217728
size_t LargePageSizeInBytes = 0
intx LiveNodeCountInliningCutoff = 40000
intx LoopMaxUnroll = 16
intx LoopOptsCount = 43
intx LoopPercentProfileLimit = 10
uintx LoopStripMiningIter = 1000
uintx LoopStripMiningIterShortLoop = 100
intx LoopUnrollLimit = 60
intx LoopUnrollMin = 4
bool LoopUnswitching = true
bool ManagementServer = false
size_t MarkStackSize = 4194304
size_t MarkStackSizeMax = 536870912
uint MarkSweepAlwaysCompactCount = 4
uintx MarkSweepDeadRatio = 5
intx MaxBCEAEstimateLevel = 5
intx MaxBCEAEstimateSize = 150
uint64_t MaxDirectMemorySize = 0
bool MaxFDLimit = true
uintx MaxGCMinorPauseMillis = 18446744073709551615
uintx MaxGCPauseMillis = 200
uintx MaxHeapFreeRatio = 70
size_t MaxHeapSize = 4282384384
intx MaxInlineLevel = 15
intx MaxInlineSize = 35
intx MaxJNILocalCapacity = 65536
intx MaxJavaStackTraceDepth = 1024
intx MaxJumpTableSize = 65000
intx MaxJumpTableSparseness = 5
intx MaxLabelRootDepth = 1100
intx MaxLoopPad = 15
size_t MaxMetaspaceExpansion = 5439488
uintx MaxMetaspaceFreeRatio = 70
size_t MaxMetaspaceSize = 18446744073709551615
size_t MaxNewSize = 2569011200
intx MaxNodeLimit = 80000
uint64_t MaxRAM = 137438953472
uintx MaxRAMFraction = 4
double MaxRAMPercentage = 25.000000
intx MaxRecursiveInlineLevel = 1
uintx MaxTenuringThreshold = 15
intx MaxTrivialSize = 6
intx MaxVectorSize = 32
ccstr MetaspaceReclaimPolicy = balanced
size_t MetaspaceSize = 22020096
bool MethodFlushing = true
size_t MinHeapDeltaBytes = 2097152
uintx MinHeapFreeRatio = 40
size_t MinHeapSize = 8388608
intx MinInliningThreshold = 250
intx MinJumpTableSize = 10
size_t MinMetaspaceExpansion = 327680
uintx MinMetaspaceFreeRatio = 40
uintx MinRAMFraction = 2
double MinRAMPercentage = 50.000000
uintx MinSurvivorRatio = 3
size_t MinTLABSize = 2048
intx MultiArrayExpandLimit = 6
uintx NUMAChunkResizeWeight = 20
size_t NUMAInterleaveGranularity = 2097152
uintx NUMAPageScanRate = 256
size_t NUMASpaceResizeRate = 1073741824
bool NUMAStats = false
ccstr NativeMemoryTracking = off
bool NeverActAsServerClassMachine = false
bool NeverTenure = false
uintx NewRatio = 2
size_t NewSize = 1363144
size_t NewSizeThreadIncrease = 5320
intx NmethodSweepActivity = 10
intx NodeLimitFudgeFactor = 2000
uintx NonNMethodCodeHeapSize = 5839372
uintx NonProfiledCodeHeapSize = 122909434
intx NumberOfLoopInstrToAlign = 4
intx ObjectAlignmentInBytes = 8 {
size_t OldPLABSize = 1024
size_t OldSize = 5452592
bool OmitStackTraceInFastThrow = true
ccstrlist OnError =
ccstrlist OnOutOfMemoryError =
intx OnStackReplacePercentage = 140
bool OptimizeFill = false
bool OptimizePtrCompare = true
bool OptimizeStringConcat = true
bool OptoBundling = false
intx OptoLoopAlignment = 16
bool OptoRegScheduling = true
bool OptoScheduling = false
uintx PLABWeight = 75
bool PSChunkLargeArrays = true
int ParGCArrayScanChunk = 50
uintx ParallelGCBufferWastePct = 10
uint ParallelGCThreads = 10
size_t ParallelOldDeadWoodLimiterMean = 50
size_t ParallelOldDeadWoodLimiterStdDev = 80
bool ParallelRefProcBalancingEnabled = true
bool ParallelRefProcEnabled = true
bool PartialPeelAtUnsignedTests = true
bool PartialPeelLoop = true
intx PartialPeelNewPhiDelta = 0
uintx PausePadding = 1
intx PerBytecodeRecompilationCutoff = 200
intx PerBytecodeTrapLimit = 4
intx PerMethodRecompilationCutoff = 400
intx PerMethodTrapLimit = 100
bool PerfAllowAtExitRegistration = false
bool PerfBypassFileSystemCheck = false
intx PerfDataMemorySize = 32768
intx PerfDataSamplingInterval = 50
ccstr PerfDataSaveFile =
bool PerfDataSaveToFile = false
bool PerfDisableSharedMem = false
intx PerfMaxStringConstLength = 1024
size_t PreTouchParallelChunkSize = 1073741824
bool PreferInterpreterNativeStubs = false
intx PrefetchCopyIntervalInBytes = 576
intx PrefetchFieldsAhead = 1
intx PrefetchScanIntervalInBytes = 576
bool PreserveAllAnnotations = false
bool PreserveFramePointer = false
size_t PretenureSizeThreshold = 0
bool PrintClassHistogram = false
bool PrintCodeCache = false
bool PrintCodeCacheOnCompilation = false
bool PrintCommandLineFlags = false
bool PrintCompilation = false
bool PrintConcurrentLocks = false
bool PrintExtendedThreadInfo = false
bool PrintFlagsFinal = true
bool PrintFlagsInitial = false
bool PrintFlagsRanges = false
bool PrintGC = false
bool PrintGCDetails = false
bool PrintHeapAtSIGBREAK = true
bool PrintSharedArchiveAndExit = false
bool PrintSharedDictionary = false
bool PrintStringTableStatistics = false
bool PrintTieredEvents = false
bool PrintVMOptions = false
bool PrintWarnings = true
uintx ProcessDistributionStride = 4
bool ProfileInterpreter = true
intx ProfileMaturityPercentage = 20
uintx ProfiledCodeHeapSize = 122909434
uintx PromotedPadding = 3
uintx QueuedAllocationWarningCount = 0
int RTMRetryCount = 5
bool RangeCheckElimination = true
bool ReassociateInvariants = true
bool RecordDynamicDumpInfo = false
bool ReduceBulkZeroing = true
bool ReduceFieldZeroing = true
bool ReduceInitialCardMarks = true
bool ReduceSignalUsage = false
intx RefDiscoveryPolicy = 0
bool RegisterFinalizersAtInit = true
bool RelaxAccessControlCheck = false
ccstr ReplayDataFile =
bool RequireSharedSpaces = false
uintx ReservedCodeCacheSize = 251658240
bool ResizePLAB = true
bool ResizeTLAB = true
bool RestoreMXCSROnJNICalls = false
bool RestrictContended = true
bool RestrictReservedStack = true
bool RewriteBytecodes = true
bool RewriteFrequentPairs = true
bool SafepointTimeout = false
intx SafepointTimeoutDelay = 10000
bool ScavengeBeforeFullGC = false
bool SegmentedCodeCache = true
intx SelfDestructTimer = 0
ccstr SharedArchiveConfigFile =
ccstr SharedArchiveFile =
size_t SharedBaseAddress = 34359738368
ccstr SharedClassListFile =
uintx SharedSymbolTableBucketSize = 4
ccstr ShenandoahGCHeuristics = adaptive
ccstr ShenandoahGCMode = satb
bool ShowCodeDetailsInExceptionMessages = true
bool ShowMessageBoxOnError = false
bool ShrinkHeapInSteps = true
size_t SoftMaxHeapSize = 4282384384
intx SoftRefLRUPolicyMSPerMB = 1000
bool SplitIfBlocks = true
intx StackRedPages = 1
intx StackReservedPages = 0
intx StackShadowPages = 7
bool StackTraceInThrowable = true
intx StackYellowPages = 3
uintx StartAggressiveSweepingAt = 10
bool StartAttachListener = false
ccstr StartFlightRecording =
uint StringDeduplicationAgeThreshold = 3
uintx StringTableSize = 65536
bool SuperWordLoopUnrollAnalysis = true
bool SuperWordReductions = true
bool SuppressFatalErrorMessage = false
uintx SurvivorPadding = 3
uintx SurvivorRatio = 8
double SweeperThreshold = 0.500000
uintx TLABAllocationWeight = 35
uintx TLABRefillWasteFraction = 64
size_t TLABSize = 0
bool TLABStats = true
uintx TLABWasteIncrement = 4
uintx TLABWasteTargetPercent = 1
uintx TargetPLABWastePct = 10
uintx TargetSurvivorRatio = 50
uintx TenuredGenerationSizeIncrement = 20
uintx TenuredGenerationSizeSupplement = 80
uintx TenuredGenerationSizeSupplementDecay = 2
intx ThreadPriorityPolicy = 0
bool ThreadPriorityVerbose = false
intx ThreadStackSize = 0
uintx ThresholdTolerance = 10
intx Tier0BackedgeNotifyFreqLog = 10
intx Tier0InvokeNotifyFreqLog = 7
intx Tier0ProfilingStartPercentage = 200
intx Tier23InlineeNotifyFreqLog = 20
intx Tier2BackEdgeThreshold = 0
intx Tier2BackedgeNotifyFreqLog = 14
intx Tier2CompileThreshold = 0
intx Tier2InvokeNotifyFreqLog = 11
intx Tier3BackEdgeThreshold = 60000
intx Tier3BackedgeNotifyFreqLog = 13
intx Tier3CompileThreshold = 2000
intx Tier3DelayOff = 2
intx Tier3DelayOn = 5
intx Tier3InvocationThreshold = 200
intx Tier3InvokeNotifyFreqLog = 10
intx Tier3LoadFeedback = 5
intx Tier3MinInvocationThreshold = 100
intx Tier4BackEdgeThreshold = 40000
intx Tier4CompileThreshold = 15000
intx Tier4InvocationThreshold = 5000
intx Tier4LoadFeedback = 3
intx Tier4MinInvocationThreshold = 600
bool TieredCompilation = true
intx TieredCompileTaskTimeout = 50
intx TieredRateUpdateMaxTime = 25
intx TieredRateUpdateMinTime = 1
intx TieredStopAtLevel = 4
bool TimeLinearScan = false
ccstr TraceJVMTI =
intx TrackedInitializationLimit = 50
bool TrapBasedNullChecks = false
bool TrapBasedRangeChecks = false
intx TypeProfileArgsLimit = 2
uintx TypeProfileLevel = 111
intx TypeProfileMajorReceiverPercent = 90
intx TypeProfileParmsLimit = 2
intx TypeProfileWidth = 2
intx UnguardOnExecutionViolation = 0
bool UseAES = true
intx UseAVX = 2
bool UseAdaptiveGenerationSizePolicyAtMajorCollection = true
bool UseAdaptiveGenerationSizePolicyAtMinorCollection = true
bool UseAdaptiveNUMAChunkSizing = true
bool UseAdaptiveSizeDecayMajorGCCost = true
bool UseAdaptiveSizePolicy = true
bool UseAdaptiveSizePolicyFootprintGoal = true
bool UseAdaptiveSizePolicyWithSystemGC = false
bool UseAddressNop = true
bool UseBASE64Intrinsics = false
bool UseBMI1Instructions = true
bool UseBMI2Instructions = true
bool UseBiasedLocking = false
bool UseBimorphicInlining = true
bool UseCLMUL = true
bool UseCMoveUnconditionally = false
bool UseCodeAging = true
bool UseCodeCacheFlushing = true
bool UseCompiler = true
bool UseCompressedClassPointers = true {
bool UseCompressedOops = true {
bool UseCondCardMark = false
bool UseCountLeadingZerosInstruction = true
bool UseCountTrailingZerosInstruction = true
bool UseCountedLoopSafepoints = true
bool UseCounterDecay = true
bool UseDivMod = true
bool UseDynamicNumberOfCompilerThreads = true
bool UseDynamicNumberOfGCThreads = true
bool UseEmptySlotsInSupers = true
bool UseFMA = true
bool UseFPUForSpilling = true
bool UseFastJNIAccessors = true
bool UseFastStosb = false
bool UseG1GC = true
bool UseGCOverheadLimit = true
bool UseHeavyMonitors = false
bool UseInlineCaches = true
bool UseInterpreter = true
bool UseJumpTables = true
bool UseLargePages = false
bool UseLargePagesIndividualAllocation = false
bool UseLoopCounter = true
bool UseLoopInvariantCodeMotion = true
bool UseLoopPredicate = true
bool UseMaximumCompactionOnSystemGC = true
bool UseNUMA = false
bool UseNUMAInterleaving = false
bool UseNewLongLShift = true
bool UseNotificationThread = true
bool UseOSErrorReporting = false
bool UseOnStackReplacement = true
bool UseOnlyInlinedBimorphic = true
bool UseOptoBiasInlining = false
bool UsePSAdaptiveSurvivorSizePolicy = true
bool UseParallelGC = false
bool UsePerfData = true
bool UsePopCountInstruction = true
bool UseProfiledLoopPredicate = true
bool UseRTMDeopt = false
bool UseRTMLocking = false
bool UseSHA = true
intx UseSSE = 4
bool UseSSE42Intrinsics = true
bool UseSerialGC = false
bool UseSharedSpaces = true
bool UseShenandoahGC = false
bool UseSignalChaining = true
bool UseStoreImmI16 = true
bool UseStringDeduplication = false
bool UseSubwordForMaxVector = true
bool UseSuperWord = true
bool UseTLAB = true
bool UseThreadPriorities = true
bool UseTypeProfile = true
bool UseTypeSpeculation = true
bool UseUnalignedLoadStores = true
bool UseVectorCmov = false
bool UseXMMForArrayCopy = true
bool UseXMMForObjInit = true
bool UseXmmI2D = true
bool UseXmmI2F = true
bool UseXmmLoadAndClearUpper = true
bool UseXmmRegToRegMoveAll = true
bool UseZGC = false
intx VMThreadPriority = -1
intx VMThreadStackSize = 0
intx ValueMapInitialSize = 11
intx ValueMapMaxLoopSize = 8
intx ValueSearchLimit = 1000
bool VerifySharedSpaces = false
uintx YoungGenerationSizeIncrement = 20
uintx YoungGenerationSizeSupplement = 80
uintx YoungGenerationSizeSupplementDecay = 8
size_t YoungPLABSize = 4096
double ZAllocationSpikeTolerance = 2.000000
double ZCollectionInterval = 0.000000
double ZFragmentationLimit = 25.000000
size_t ZMarkStackSpaceLimit = 8589934592
bool ZProactive = true
bool ZUncommit = true
uintx ZUncommitDelay = 300
bool ZeroTLAB = false
openjdk version "17.0.6" 2023-01-17
OpenJDK Runtime Environment Temurin-17.0.6+10 (build 17.0.6+10)
OpenJDK 64-Bit Server VM Temurin-17.0.6+10 (build 17.0.6+10, mixed mode, sharing)

到目前为止，在本系列中，我们已经了解了 Resilience4j 及其 Retry, RateLimiter, TimeLimiter, 和 Bulkhead 模块。在本文中，我们将探索 CircuitBreaker 模块。我们将了解何时以及如何使用它，并查看一些示例。

代码示例

本文附有 GitHub 上的工作代码示例。

什么是 Resilience4j？

请参阅上一篇文章中的描述，快速了解 Resilience4j 的一般工作原理。

什么是断路器？

断路器的思想是，如果我们知道调用可能会失败或超时，则阻止对远程服务的调用。我们这样做是为了不会在我们的服务和远程服务中不必要地浪费关键资源。这样的退出也给了远程服务一些时间来恢复。

我们怎么知道一个调用可能会失败？ 通过跟踪对远程服务发出的先前请求的结果。例如，如果前 10 次调用中有 8 次导致失败或超时，则下一次调用也可能会失败。

断路器通过包装对远程服务的调用来跟踪响应。在正常运行期间，当远程服务成功响应时，我们说断路器处于“闭合”状态。当处于关闭状态时，断路器正常将请求传递给远程服务。

当远程服务返回错误或超时时，断路器会增加一个内部计数器。如果错误计数超过配置的阈值，断路器将切换到“断开”状态。当处于断开状态时，断路器立即向调用者返回错误，甚至无需尝试远程调用。

经过一段配置的时间后，断路器从断开状态切换到“半开”状态。在这种状态下，它允许一些请求传递到远程服务以检查它是否仍然不可用或缓慢。 如果错误率或慢呼叫率高于配置的阈值，则切换回断开状态。但是，如果错误率或慢呼叫率低于配置的阈值，则切换到关闭状态以恢复正常操作。

断路器的类型

断路器可以基于计数或基于时间。如果最后 N 次调用失败或缓慢，则基于计数的断路器将状态从关闭切换为断开。如果最后 N 秒的响应失败或缓慢，则基于时间的断路器将切换到断开状态。在这两个断路器中，我们还可以指定失败或慢速调用的阈值。

例如，如果最近 25 次调用中有 70% 失败或需要 2 秒以上才能完成，我们可以配置一个基于计数的断路器来“断开电路”。同样，如果过去 30 秒内 80% 的调用失败或耗时超过 5 秒，我们可以告诉基于时间的断路器断开电路。

Resilience4j 的 CircuitBreaker 概念

resilience4j-circuitbreaker 的工作原理与其他 Resilience4j 模块类似。我们提供想要作为函数构造执行的代码——一个进行远程调用的 lambda 表达式或一个从远程服务中检索到的某个值的 Supplier，等等——并且断路器用代码修饰它 如果需要，跟踪响应并切换状态。

Resilience4j 同时支持基于计数和基于时间的断路器。

我们使用 slidingWindowType() 配置指定断路器的类型。此配置可以采用两个值之一 –
SlidingWindowType.COUNT_BASED 或
SlidingWindowType.TIME_BASED。

failureRateThreshold() 和 slowCallRateThreshold() 以百分比形式配置失败率阈值和慢速调用率。

slowCallDurationThreshold() 以秒为单位配置调用被认为慢的时间。

我们可以指定一个 minimumNumberOfCalls()，在断路器可以计算错误率或慢速调用率之前需要它。

如前所述，断路器在一定时间后从断开状态切换到半断开状态，以检查远程服务的情况。waitDurationInOpenState() 指定断路器在切换到半开状态之前应等待的时间。

permittedNumberOfCallsInHalfOpenState() 配置在半开状态下允许的调用次数，
maxWaitDurationInHalfOpenState() 确定断路器在切换回开状态之前可以保持在半开状态的时间。

此配置的默认值 0 意味着断路器将无限等待，直到所有
permittedNumberOfCallsInHalfOpenState() 完成。

默认情况下，断路器将任何异常视为失败。但是我们可以对此进行调整，以使用 recordExceptions() 配置指定应视为失败的异常列表和使用 ignoreExceptions() 配置忽略的异常列表。

如果我们在确定异常应该被视为失败还是忽略时想要更精细的控制，我们可以提供 Predicate<Throwable> 作为 recordException() 或 ignoreException() 配置。

当断路器拒绝处于断开状态的呼叫时，它会抛出 CallNotPermittedException。我们可以使用 writablestacktraceEnabled() 配置控制 CallNotPermittedException 的堆栈跟踪中的信息量。

使用 Resilience4j CircuitBreaker模块

让我们看看如何使用
resilience4j-circuitbreaker 模块中可用的各种功能。

我们将使用与本系列前几篇文章相同的示例。假设我们正在为一家航空公司建立一个网站，以允许其客户搜索和预订航班。我们的服务与 FlightSearchService 类封装的远程服务对话。

使用 Resilience4j 断路器时，CircuitBreakerRegistry、CircuitBreakerConfig 和 CircuitBreaker 是我们使用的主要抽象。

CircuitBreakerRegistry 是用于创建和管理 CircuitBreaker 对象的工厂。

CircuitBreakerConfig 封装了上一节中的所有配置。每个 CircuitBreaker 对象都与一个 CircuitBreakerConfig 相关联。

第一步是创建一个 CircuitBreakerConfig：

CircuitBreakerConfig config = CircuitBreakerConfig.ofDefaults();

这将创建一个具有以下默认值的 CircuitBreakerConfig：

基于计数的断路器

假设我们希望断路器在最近 10 次调用中有 70% 失败时断开：

CircuitBreakerConfig config = CircuitBreakerConfig
  .custom()
  .slidingWindowType(SlidingWindowType.COUNT_BASED)
  .slidingWindowSize(10)
  .failureRateThreshold(70.0f)
  .build();

然后我们用这个配置创建一个 CircuitBreaker：

CircuitBreakerRegistry registry = CircuitBreakerRegistry.of(config);
CircuitBreaker circuitBreaker = registry.circuitBreaker("flightSearchService");

现在让我们表达我们的代码以作为 Supplier 运行航班搜索并使用 circuitbreaker 装饰它：

Supplier<List<Flight>> flightsSupplier =
  () -> service.searchFlights(request);
Supplier<List<Flight>> decoratedFlightsSupplier =
  circuitBreaker.decorateSupplier(flightsSupplier);

最后，让我们调用几次修饰操作来了解断路器的工作原理。我们可以使用 CompletableFuture 来模拟来自用户的并发航班搜索请求：

for (int i=0; i<20; i++) {
  try {
    System.out.println(decoratedFlightsSupplier.get());
  }
  catch (...) {
    // Exception handling
  }
}

输出显示前几次飞行搜索成功，然后是 7 次飞行搜索失败。此时，断路器断开并为后续调用抛出 CallNotPermittedException：

Searching for flights; current time = 12:01:12 884
Flight search successful
[Flight{flightNumber='XY 765', flightDate='12/31/2020', from='NYC', to='LAX'}, ... ]
Searching for flights; current time = 12:01:12 954
Flight search successful
[Flight{flightNumber='XY 765', flightDate='12/31/2020', from='NYC', to='LAX'}, ... ]
Searching for flights; current time = 12:01:12 957
Flight search successful
[Flight{flightNumber='XY 765', flightDate='12/31/2020', from='NYC', to='LAX'}, ... ]
Searching for flights; current time = 12:01:12 958
io.reflectoring.resilience4j.circuitbreaker.exceptions.FlightServiceException: Error occurred during flight search
... stack trace omitted ...
io.github.resilience4j.circuitbreaker.CallNotPermittedException: CircuitBreaker 'flightSearchService' is OPEN and does not permit further calls
... other lines omitted ...
io.reflectoring.resilience4j.circuitbreaker.Examples.countBasedSlidingWindow_FailedCalls(Examples.java:56)
  at io.reflectoring.resilience4j.circuitbreaker.Examples.main(Examples.java:229)

现在，假设我们希望断路器在最后 10 个调用中有 70% 需要 2 秒或更长时间才能完成：

CircuitBreakerConfig config = CircuitBreakerConfig
  .custom()
  .slidingWindowType(SlidingWindowType.COUNT_BASED)
  .slidingWindowSize(10)
  .slowCallRateThreshold(70.0f)
  .slowCallDurationThreshold(Duration.ofSeconds(2))
  .build();

示例输出中的时间戳显示请求始终需要 2 秒才能完成。在 7 次缓慢响应后，断路器断开并且不允许进一步调用：

Searching for flights; current time = 12:26:27 901
Flight search successful
[Flight{flightNumber='XY 765', flightDate='12/31/2020', from='NYC', to='LAX'}, ... ]
Searching for flights; current time = 12:26:29 953
Flight search successful
[Flight{flightNumber='XY 765', flightDate='12/31/2020', from='NYC', to='LAX'}, ... ]
Searching for flights; current time = 12:26:31 957
Flight search successful
... other lines omitted ...
Searching for flights; current time = 12:26:43 966
Flight search successful
[Flight{flightNumber='XY 765', flightDate='12/31/2020', from='NYC', to='LAX'}, ... ]
io.github.resilience4j.circuitbreaker.CallNotPermittedException: CircuitBreaker 'flightSearchService' is OPEN and does not permit further calls
... stack trace omitted ...
        at io.reflectoring.resilience4j.circuitbreaker.Examples.main(Examples.java:231)
io.github.resilience4j.circuitbreaker.CallNotPermittedException: CircuitBreaker 'flightSearchService' is OPEN and does not permit further calls
... stack trace omitted ...
        at io.reflectoring.resilience4j.circuitbreaker.Examples.main(Examples.java:231)

通常我们会配置一个具有故障率和慢速调用率阈值的断路器：

CircuitBreakerConfig config = CircuitBreakerConfig
  .custom()
  .slidingWindowType(SlidingWindowType.COUNT_BASED)
  .slidingWindowSize(10)
  .failureRateThreshold(70.0f)
  .slowCallRateThreshold(70.0f)
  .slowCallDurationThreshold(Duration.ofSeconds(2))
  .build();

基于时间的断路器

假设我们希望断路器在过去 10 秒内 70% 的请求失败时断开：

CircuitBreakerConfig config = CircuitBreakerConfig
  .custom()
  .slidingWindowType(SlidingWindowType.COUNT_BASED)
  .slidingWindowSize(10)
  .failureRateThreshold(70.0f)
  .slowCallRateThreshold(70.0f)
  .slowCallDurationThreshold(Duration.ofSeconds(2))
  .build();

我们创建了 CircuitBreaker，将航班搜索调用表示为 Supplier<List<Flight>> 并使用 CircuitBreaker 对其进行装饰，就像我们在上一节中所做的那样。

以下是多次调用修饰操作后的示例输出：

Start time: 18:51:01 552
Searching for flights; current time = 18:51:01 582
Flight search successful
[Flight{flightNumber='XY 765', ... }]
... other lines omitted ...
Searching for flights; current time = 18:51:01 631
io.reflectoring.resilience4j.circuitbreaker.exceptions.FlightServiceException: Error occurred during flight search
... stack trace omitted ...
Searching for flights; current time = 18:51:01 632
io.reflectoring.resilience4j.circuitbreaker.exceptions.FlightServiceException: Error occurred during flight search
... stack trace omitted ...
Searching for flights; current time = 18:51:01 633
... other lines omitted ...
io.github.resilience4j.circuitbreaker.CallNotPermittedException: CircuitBreaker 'flightSearchService' is OPEN and does not permit further calls
... other lines omitted ...

前 3 个请求成功，接下来的 7 个请求失败。此时断路器断开，后续请求因抛出 CallNotPermittedException 而失败。

现在，假设我们希望断路器在过去 10 秒内 70% 的调用需要 1 秒或更长时间才能完成：

CircuitBreakerConfig config = CircuitBreakerConfig
  .custom()
  .slidingWindowType(SlidingWindowType.TIME_BASED)
  .minimumNumberOfCalls(10)
  .slidingWindowSize(10)
  .slowCallRateThreshold(70.0f)
  .slowCallDurationThreshold(Duration.ofSeconds(1))
  .build();

示例输出中的时间戳显示请求始终需要 1 秒才能完成。在 10 个请求（minimumNumberOfCalls）之后，当断路器确定 70% 的先前请求花费了 1 秒或更长时间时，它断开电路：

Start time: 19:06:37 957
Searching for flights; current time = 19:06:37 979
Flight search successful
[Flight{flightNumber='XY 765', flightDate='12/31/2020', from='NYC', to='LAX'}, ... }]
Searching for flights; current time = 19:06:39 066
Flight search successful
[Flight{flightNumber='XY 765', flightDate='12/31/2020', from='NYC', to='LAX'}, ... }]
Searching for flights; current time = 19:06:40 070
Flight search successful
[Flight{flightNumber='XY 765', flightDate='12/31/2020', from='NYC', to='LAX'}, ... }]
Searching for flights; current time = 19:06:41 070
... other lines omitted ...
io.github.resilience4j.circuitbreaker.CallNotPermittedException: CircuitBreaker 'flightSearchService' is OPEN and does not permit further calls
... stack trace omitted ...

通常我们会配置一个具有故障率和慢速调用率阈值的基于时间的断路器：

指定断开状态下的等待时间

假设我们希望断路器处于断开状态时等待 10 秒，然后转换到半断开状态并让一些请求传递到远程服务：

CircuitBreakerConfig config = CircuitBreakerConfig
  .custom()
  .slidingWindowType(SlidingWindowType.TIME_BASED)
  .slidingWindowSize(10)
  .minimumNumberOfCalls(10)
  .failureRateThreshold(70.0f)
  .slowCallRateThreshold(70.0f)
  .slowCallDurationThreshold(Duration.ofSeconds(2))
  .build();

示例输出中的时间戳显示断路器最初转换为断开状态，在接下来的 10 秒内阻止一些调用，然后更改为半断开状态。后来，在半开状态时一致的成功响应导致它再次切换到关闭状态：

Searching for flights; current time = 20:55:58 735
Flight search successful
[Flight{flightNumber='XY 765', flightDate='12/31/2020', from='NYC', to='LAX'}, ... }]
Searching for flights; current time = 20:55:59 812
Flight search successful
[Flight{flightNumber='XY 765', flightDate='12/31/2020', from='NYC', to='LAX'}, ... }]
Searching for flights; current time = 20:56:00 816
... other lines omitted ...
io.reflectoring.resilience4j.circuitbreaker.exceptions.FlightServiceException: Flight search failed
    at
... stack trace omitted ...
2020-12-13T20:56:03.850115+05:30: CircuitBreaker 'flightSearchService' changed state from CLOSED to OPEN
2020-12-13T20:56:04.851700+05:30: CircuitBreaker 'flightSearchService' recorded a call which was not permitted.
2020-12-13T20:56:05.852220+05:30: CircuitBreaker 'flightSearchService' recorded a call which was not permitted.
2020-12-13T20:56:06.855338+05:30: CircuitBreaker 'flightSearchService' recorded a call which was not permitted.
... other similar lines omitted ...
2020-12-13T20:56:12.862362+05:30: CircuitBreaker 'flightSearchService' recorded a call which was not permitted.
2020-12-13T20:56:13.865436+05:30: CircuitBreaker 'flightSearchService' changed state from OPEN to HALF_OPEN
Searching for flights; current time = 20:56:13 865
Flight search successful
[Flight{flightNumber='XY 765', flightDate='12/31/2020', from='NYC', to='LAX'}, ... }]
... other similar lines omitted ...
2020-12-13T20:56:16.877230+05:30: CircuitBreaker 'flightSearchService' changed state from HALF_OPEN to CLOSED
[Flight{flightNumber='XY 765', flightDate='12/31/2020', from='NYC', to='LAX'}, ... }]
Searching for flights; current time = 20:56:17 879
Flight search successful
[Flight{flightNumber='XY 765', flightDate='12/31/2020', from='NYC', to='LAX'}, ... }]
... other similar lines omitted ...

指定回退方法

使用断路器时的常见模式是指定在电路断开时要调用的回退方法。回退方法可以为不允许的远程调用提供一些默认值或行为。

我们可以使用 Decorators 实用程序类进行设置。Decorators 是来自 resilience4j-all 模块的构建器，具有 withCircuitBreaker()、withRetry()、withRateLimiter() 等方法，可帮助将多个 Resilience4j 装饰器应用于 Supplier、Function 等。

当断路器断开并抛出 CallNotPermittedException 时，我们将使用它的 withFallback() 方法从本地缓存返回航班搜索结果：

Supplier<List<Flight>> flightsSupplier = () -> service.searchFlights(request);
Supplier<List<Flight>> decorated = Decorators
  .ofSupplier(flightsSupplier)
  .withCircuitBreaker(circuitBreaker)
  .withFallback(Arrays.asList(CallNotPermittedException.class),
                e -> this.getFlightSearchResultsFromCache(request))
  .decorate();

以下示例输出显示了断路器断开后从缓存中返回的搜索结果：

Searching for flights; current time = 22:08:29 735
Flight search successful
[Flight{flightNumber='XY 765', flightDate='12/31/2020', from='NYC', to='LAX'}, ... }]
Searching for flights; current time = 22:08:29 854
Flight search successful
[Flight{flightNumber='XY 765', flightDate='12/31/2020', from='NYC', to='LAX'}, ... }]
Searching for flights; current time = 22:08:29 855
Flight search successful
[Flight{flightNumber='XY 765', flightDate='12/31/2020', from='NYC', to='LAX'}, ... }]
Searching for flights; current time = 22:08:29 855
2020-12-13T22:08:29.856277+05:30: CircuitBreaker 'flightSearchService' recorded an error: 'io.reflectoring.resilience4j.circuitbreaker.exceptions.FlightServiceException: Error occurred during flight search'. Elapsed time: 0 ms
Searching for flights; current time = 22:08:29 912
... other lines omitted ...
2020-12-13T22:08:29.926691+05:30: CircuitBreaker 'flightSearchService' changed state from CLOSED to OPEN
Returning flight search results from cache
[Flight{flightNumber='XY 765', flightDate='12/31/2020', from='NYC', to='LAX'}, ... }]
Returning flight search results from cache
[Flight{flightNumber='XY 765', flightDate='12/31/2020', from='NYC', to='LAX'}, ... }]
... other lines omitted ...

减少 Stacktrace 中的信息

每当断路器断开时，它就会抛出 CallNotPermittedException：

io.github.resilience4j.circuitbreaker.CallNotPermittedException: CircuitBreaker 'flightSearchService' is OPEN and does not permit further calls
    at io.github.resilience4j.circuitbreaker.CallNotPermittedException.createCallNotPermittedException(CallNotPermittedException.java:48)
... other lines in stack trace omitted ...
at io.reflectoring.resilience4j.circuitbreaker.Examples.timeBasedSlidingWindow_SlowCalls(Examples.java:169)
    at io.reflectoring.resilience4j.circuitbreaker.Examples.main(Examples.java:263)

除了第一行，堆栈跟踪中的其他行没有增加太多价值。如果 CallNotPermittedException 发生多次，这些堆栈跟踪行将在我们的日志文件中重复。

我们可以通过将 writablestacktraceEnabled() 配置设置为 false 来减少堆栈跟踪中生成的信息量：

CircuitBreakerConfig config = CircuitBreakerConfig
  .custom()
  .slidingWindowType(SlidingWindowType.COUNT_BASED)
  .slidingWindowSize(10)
  .failureRateThreshold(70.0f)
  .writablestacktraceEnabled(false)
  .build();

现在，当 CallNotPermittedException 发生时，堆栈跟踪中只存在一行：

Searching for flights; current time = 20:29:24 476
Flight search successful
[Flight{flightNumber='XY 765', flightDate='12/31/2020', from='NYC', to='LAX'}, ... ]
Searching for flights; current time = 20:29:24 540
Flight search successful
[Flight{flightNumber='XY 765', flightDate='12/31/2020', from='NYC', to='LAX'}, ... ]
... other lines omitted ...
io.github.resilience4j.circuitbreaker.CallNotPermittedException: CircuitBreaker 'flightSearchService' is OPEN and does not permit further calls
io.github.resilience4j.circuitbreaker.CallNotPermittedException: CircuitBreaker 'flightSearchService' is OPEN and does not permit further calls
...

其他有用的方法

与 Retry 模块类似，CircuitBreaker 也有像 ignoreExceptions()、recordExceptions() 等方法，让我们可以指定 CircuitBreaker 在跟踪调用结果时应该忽略和考虑哪些异常。

例如，我们可能不想忽略来自远程飞行服务的 SeatsUnavailableException – 在这种情况下，我们真的不想断开电路。

与我们见过的其他 Resilience4j 模块类似，CircuitBreaker 还提供了额外的方法，如 decorateCheckedSupplier()、decorateCompletionStage()、decorateRunnable()、decorateConsumer() 等，因此我们可以在 Supplier 之外的其他结构中提供我们的代码。

断路器事件

CircuitBreaker 有一个 EventPublisher 可以生成以下类型的事件：

• CircuitBreakerOnSuccessEvent,
• CircuitBreakerOnErrorEvent,
• CircuitBreakerOnStateTransitionEvent,
• CircuitBreakerOnResetEvent,
• CircuitBreakerOnIgnoredErrorEvent,
• CircuitBreakerOnCallNotPermittedEvent,
• CircuitBreakerOnFailureRateExceededEvent 以及
• CircuitBreakerOnSlowCallRateExceededEvent.

我们可以监听这些事件并记录它们，例如：

circuitBreaker.getEventPublisher()
  .onCallNotPermitted(e -> System.out.println(e.toString()));
circuitBreaker.getEventPublisher()
  .onError(e -> System.out.println(e.toString()));
circuitBreaker.getEventPublisher()
  .onFailureRateExceeded(e -> System.out.println(e.toString()));
circuitBreaker.getEventPublisher().onStateTransition(e -> System.out.println(e.toString()));

以下是示例的日志输出：

2020-12-13T22:25:52.972943+05:30: CircuitBreaker 'flightSearchService' recorded an error: 'io.reflectoring.resilience4j.circuitbreaker.exceptions.FlightServiceException: Error occurred during flight search'. Elapsed time: 0 ms
Searching for flights; current time = 22:25:52 973
... other lines omitted ...
2020-12-13T22:25:52.974448+05:30: CircuitBreaker 'flightSearchService' exceeded failure rate threshold. Current failure rate: 70.0
2020-12-13T22:25:52.984300+05:30: CircuitBreaker 'flightSearchService' changed state from CLOSED to OPEN
2020-12-13T22:25:52.985057+05:30: CircuitBreaker 'flightSearchService' recorded a call which was not permitted.
... other lines omitted ...

CircuitBreaker指标

CircuitBreake 暴露了许多指标，这些是一些重要的条目：

• 成功、失败或忽略的调用总数 (resilience4j.circuitbreaker.calls)
• 断路器状态 (resilience4j.circuitbreaker.state)
• 断路器故障率 (resilience4j.circuitbreaker.failure.rate)
• 未被允许的调用总数 (resilience4.circuitbreaker.not.permitted.calls)
• 断路器的缓慢调用 (resilience4j.circuitbreaker.slow.call.rate)

首先，我们像往常一样创建 CircuitBreakerConfig、CircuitBreakerRegistry 和 CircuitBreaker。然后，我们创建一个 MeterRegistry 并将 CircuitBreakerRegistry 绑定到它：

MeterRegistry meterRegistry = new SimpleMeterRegistry();
TaggedCircuitBreakerMetrics.ofCircuitBreakerRegistry(registry)
  .bindTo(meterRegistry);

运行几次断路器修饰操作后，我们显示捕获的指标。这是一些示例输出：

The number of slow failed calls which were slower than a certain threshold - resilience4j.circuitbreaker.slow.calls: 0.0
The states of the circuit breaker - resilience4j.circuitbreaker.state: 0.0, state: metrics_only
Total number of not permitted calls - resilience4j.circuitbreakernot.permitted.calls: 0.0
The slow call of the circuit breaker - resilience4j.circuitbreaker.slow.call.rate: -1.0
The states of the circuit breaker - resilience4j.circuitbreaker.state: 0.0, state: half_open
Total number of successful calls - resilience4j.circuitbreaker.calls: 0.0, kind: successful
The failure rate of the circuit breaker - resilience4j.circuitbreaker.failure.rate: -1.0

在实际应用中，我们会定期将数据导出到监控系统并在仪表板上进行分析。

结论

在本文中，我们学习了如何使用 Resilience4j 的 Circuitbreaker 模块在远程服务返回错误时暂停向其发出请求。我们了解了为什么这很重要，还看到了一些有关如何配置它的实际示例。

您可以使用 GitHub 上的代码来演示一个完整的应用程序。

本文译自：Implementing a Circuit Breaker with Resilience4j – Reflectoring