浮点运算的精确性，鹏磊最烦的就是不同平台结果不一样。同样的代码，在 Windows 上跑一个结果，在 Linux 上跑另一个结果，调试起来特别麻烦。JDK 17 的 JEP 306 恢复了始终严格的浮点语义，让所有浮点运算默认都是严格的，确保跨平台一致性。
恢复始终严格的浮点语义是 JEP 306 引入的特性，让所有浮点运算默认都遵循 IEEE 754 标准，不再需要显式使用 strictfp 关键字。这玩意儿确保了跨平台一致性，同样的代码在不同平台上产生相同的结果，对于科学计算、金融计算这些需要精确性的场景特别重要。
什么是严格的浮点语义
严格的浮点语义（Strict Floating-Point Semantics）是指浮点运算必须遵循 IEEE 754 标准，不允许平台特定的优化。这意味着：
- 精度一致：所有浮点运算使用相同的精度
- 结果一致：同样的运算在不同平台上产生相同的结果
- 行为可预测：浮点运算的行为是可预测的
// 严格的浮点语义示例
public class StrictFloatingPoint {
public static void main(String[] args) {
double a = 0.1; // 0.1
double b = 0.2; // 0.2
double c = a + b; // 0.3（严格语义下结果一致）
System.out.println("结果: " + c); // 输出: 结果: 0.30000000000000004
// 注意：由于浮点数精度问题，结果可能不是精确的 0.3
// 但在严格语义下，这个结果在所有平台上都是一致的
}
}
严格的浮点语义确保结果一致，即使有精度问题，在不同平台上也是相同的。
为什么需要恢复
在 JDK 1.2 之前，Java 的浮点运算默认是严格的。但从 JDK 1.2 开始，为了性能优化，允许平台特定的浮点运算优化，这导致了：
- 跨平台不一致：同样的代码在不同平台上可能产生不同的结果
- 调试困难：不同平台的结果不同，调试起来特别麻烦
- 可预测性差：浮点运算的行为不可预测
JDK 17 恢复了始终严格的浮点语义，解决了这些问题。
strictfp 关键字的变化
在 JDK 17 之前，需要使用 strictfp 关键字来启用严格的浮点语义：
// JDK 17 之前：需要显式使用 strictfp
public strictfp class StrictClass {
public strictfp double calculate(double a, double b) {
return a + b; // 严格语义
}
}
// JDK 17 之后：默认就是严格的，strictfp 变成可选
public class StrictClass {
public double calculate(double a, double b) {
return a + b; // 默认就是严格语义
}
}
JDK 17 之后，所有浮点运算默认都是严格的，strictfp 关键字变成可选的了。
实际影响
恢复始终严格的浮点语义对代码的影响：
影响一：跨平台一致性
所有浮点运算在不同平台上产生相同的结果：
// 跨平台一致性示例
public class CrossPlatformConsistency {
public static void main(String[] args) {
// 这些运算在所有平台上都产生相同的结果
double a = Math.sqrt(2.0); // 平方根
double b = Math.sin(Math.PI / 2); // 正弦
double c = Math.log(Math.E); // 自然对数
System.out.println("sqrt(2): " + a); // 输出: sqrt(2): 1.4142135623730951
System.out.println("sin(π/2): " + b); // 输出: sin(π/2): 1.0
System.out.println("log(e): " + c); // 输出: log(e): 1.0
// 这些结果在所有平台上都是一致的
}
}
跨平台一致性让代码更容易调试和维护。
影响二：性能考虑
严格的浮点语义可能会影响性能，但通常影响很小：
// 性能对比示例
public class PerformanceComparison {
public static void main(String[] args) {
int iterations = 10_000_000; // 1000 万次迭代
// 测试浮点运算性能
long start = System.nanoTime(); // 开始时间
double sum = 0.0; // 累加和
for (int i = 0; i < iterations; i++) {
sum += Math.sin(i); // 正弦运算
}
long time = System.nanoTime() - start; // 计算时间
System.out.println("时间: " + time / 1_000_000 + " ms"); // 输出时间
System.out.println("结果: " + sum); // 输出结果
// 严格语义下性能可能稍慢，但通常影响很小
}
}
严格语义可能会影响性能，但通常影响很小，而且换来的是跨平台一致性。
影响三：科学计算
科学计算需要精确性和一致性：
// 科学计算示例
public class ScientificComputing {
// 计算圆的面积
public static double circleArea(double radius) {
return Math.PI * radius * radius; // π * r²
}
// 计算球的体积
public static double sphereVolume(double radius) {
return (4.0 / 3.0) * Math.PI * radius * radius * radius; // (4/3) * π * r³
}
// 计算复利
public static double compoundInterest(double principal, double rate, int years) {
return principal * Math.pow(1 + rate, years); // P * (1 + r)^n
}
public static void main(String[] args) {
// 这些计算在所有平台上都产生相同的结果
double area = circleArea(5.0); // 计算面积
double volume = sphereVolume(5.0); // 计算体积
double interest = compoundInterest(1000.0, 0.05, 10); // 计算复利
System.out.println("面积: " + area); // 输出面积
System.out.println("体积: " + volume); // 输出体积
System.out.println("复利: " + interest); // 输出复利
}
}
科学计算需要精确性和一致性，严格语义确保了这一点。
实际应用：金融计算
金融计算对精确性要求特别高：
// 金融计算示例
public class FinancialCalculation {
// 计算贷款月供
public static double monthlyPayment(double principal, double annualRate, int months) {
double monthlyRate = annualRate / 12.0; // 月利率
double factor = Math.pow(1 + monthlyRate, months); // (1 + r)^n
return principal * (monthlyRate * factor) / (factor - 1); // P * (r * (1+r)^n) / ((1+r)^n - 1)
}
// 计算现值
public static double presentValue(double futureValue, double rate, int periods) {
return futureValue / Math.pow(1 + rate, periods); // FV / (1 + r)^n
}
// 计算终值
public static double futureValue(double presentValue, double rate, int periods) {
return presentValue * Math.pow(1 + rate, periods); // PV * (1 + r)^n
}
public static void main(String[] args) {
// 这些计算在所有平台上都产生相同的结果
double payment = monthlyPayment(100000.0, 0.05, 360); // 计算月供
double pv = presentValue(100000.0, 0.05, 10); // 计算现值
double fv = futureValue(100000.0, 0.05, 10); // 计算终值
System.out.println("月供: " + payment); // 输出月供
System.out.println("现值: " + pv); // 输出现值
System.out.println("终值: " + fv); // 输出终值
}
}
金融计算对精确性要求特别高，严格语义确保了计算结果的一致性。
实际应用：数值分析
数值分析需要精确的浮点运算：
// 数值分析示例
public class NumericalAnalysis {
// 牛顿法求根
public static double newtonMethod(double x0, double tolerance) {
double x = x0; // 初始值
int iterations = 0; // 迭代次数
while (iterations < 100) {
double fx = x * x - 2.0; // f(x) = x² - 2
double fpx = 2.0 * x; // f'(x) = 2x
if (Math.abs(fpx) < 1e-10) {
break; // 避免除零
}
double xNew = x - fx / fpx; // x_new = x - f(x) / f'(x)
if (Math.abs(xNew - x) < tolerance) {
return xNew; // 收敛
}
x = xNew; // 更新 x
iterations++; // 增加迭代次数
}
return x; // 返回结果
}
// 梯形法数值积分
public static double trapezoidalRule(double a, double b, int n) {
double h = (b - a) / n; // 步长
double sum = 0.0; // 累加和
for (int i = 1; i < n; i++) {
double x = a + i * h; // x 坐标
sum += Math.sin(x); // 累加函数值
}
return h * ((Math.sin(a) + Math.sin(b)) / 2.0 + sum); // 梯形法公式
}
public static void main(String[] args) {
// 这些计算在所有平台上都产生相同的结果
double root = newtonMethod(1.0, 1e-10); // 求根
double integral = trapezoidalRule(0.0, Math.PI, 1000); // 数值积分
System.out.println("根: " + root); // 输出根
System.out.println("积分: " + integral); // 输出积分
}
}
数值分析需要精确的浮点运算，严格语义确保了计算结果的一致性。
注意事项
注意事项一：精度问题
浮点数本身有精度问题，严格语义不能解决这个问题：
// 精度问题示例
public class PrecisionIssue {
public static void main(String[] args) {
// 浮点数精度问题
double a = 0.1; // 0.1
double b = 0.2; // 0.2
double c = a + b; // 0.3
System.out.println("0.1 + 0.2 = " + c); // 输出: 0.1 + 0.2 = 0.30000000000000004
System.out.println("c == 0.3: " + (c == 0.3)); // 输出: c == 0.3: false
// 严格语义不能解决精度问题，但能确保跨平台一致性
// 如果需要精确的十进制运算，应该使用 BigDecimal
}
}
严格语义不能解决精度问题，但能确保跨平台一致性。
注意事项二：性能影响
严格语义可能会影响性能，但通常影响很小：
// 性能影响示例
public class PerformanceImpact {
public static void main(String[] args) {
int iterations = 10_000_000; // 1000 万次迭代
// 测试浮点运算性能
long start = System.nanoTime(); // 开始时间
double sum = 0.0; // 累加和
for (int i = 0; i < iterations; i++) {
sum += Math.sqrt(i); // 平方根运算
}
long time = System.nanoTime() - start; // 计算时间
System.out.println("时间: " + time / 1_000_000 + " ms"); // 输出时间
// 严格语义下性能可能稍慢，但通常影响很小
// 如果性能是关键，可以考虑使用整数运算或其他优化
}
}
严格语义可能会影响性能，但通常影响很小，而且换来的是跨平台一致性。
注意事项三：strictfp 关键字
strictfp 关键字在 JDK 17 中变成可选的了：
// strictfp 关键字的变化
public class StrictfpKeyword {
// JDK 17 之前：需要显式使用 strictfp
// public strictfp double calculate(double a, double b) {
// return a + b;
// }
// JDK 17 之后：默认就是严格的，strictfp 变成可选
public double calculate(double a, double b) {
return a + b; // 默认就是严格语义
}
// strictfp 仍然可以使用，但不再必要
public strictfp double calculateStrict(double a, double b) {
return a + b; // 显式使用 strictfp（可选）
}
}
strictfp 关键字在 JDK 17 中变成可选的了，但为了向后兼容，仍然可以使用。
最佳实践
最佳实践一：使用 BigDecimal 进行精确计算
如果需要精确的十进制运算，应该使用 BigDecimal：
import java.math.BigDecimal;
import java.math.RoundingMode;
// 使用 BigDecimal 进行精确计算
public class BigDecimalExample {
public static void main(String[] args) {
// 使用 BigDecimal 进行精确计算
BigDecimal a = new BigDecimal("0.1"); // 0.1
BigDecimal b = new BigDecimal("0.2"); // 0.2
BigDecimal c = a.add(b); // 0.3
System.out.println("0.1 + 0.2 = " + c); // 输出: 0.1 + 0.2 = 0.3
System.out.println("c == 0.3: " + c.equals(new BigDecimal("0.3"))); // 输出: c == 0.3: true
// BigDecimal 提供精确的十进制运算
}
}
如果需要精确的十进制运算，应该使用 BigDecimal。
最佳实践二：理解浮点数精度
理解浮点数的精度限制：
// 理解浮点数精度
public class FloatPrecision {
public static void main(String[] args) {
// float 精度：约 7 位有效数字
float f1 = 1234567.0f; // float
float f2 = 1234567.1f; // float
System.out.println("f1 == f2: " + (f1 == f2)); // 输出: f1 == f2: true（精度不够）
// double 精度：约 15-17 位有效数字
double d1 = 123456789012345.0; // double
double d2 = 123456789012345.1; // double
System.out.println("d1 == d2: " + (d1 == d2)); // 输出: d1 == d2: true（精度不够）
// 理解精度限制，选择合适的类型
}
}
理解浮点数的精度限制，选择合适的类型。
最佳实践三：使用 Math 类的方法
使用 Math 类的方法进行浮点运算：
// 使用 Math 类的方法
public class MathClassExample {
public static void main(String[] args) {
// 使用 Math 类的方法
double sqrt = Math.sqrt(2.0); // 平方根
double sin = Math.sin(Math.PI / 2); // 正弦
double log = Math.log(Math.E); // 自然对数
double pow = Math.pow(2.0, 3.0); // 幂运算
System.out.println("sqrt(2): " + sqrt); // 输出: sqrt(2): 1.4142135623730951
System.out.println("sin(π/2): " + sin); // 输出: sin(π/2): 1.0
System.out.println("log(e): " + log); // 输出: log(e): 1.0
System.out.println("2^3: " + pow); // 输出: 2^3: 8.0
// Math 类的方法遵循严格语义
}
}
使用 Math 类的方法进行浮点运算，这些方法遵循严格语义。
总结
恢复始终严格的浮点语义是 JDK 17 的一个重要特性，让所有浮点运算默认都遵循 IEEE 754 标准，确保了跨平台一致性。这玩意儿对于科学计算、金融计算这些需要精确性的场景特别重要。
虽然可能会影响性能，但通常影响很小，而且换来的是跨平台一致性。建议在实际项目中注意浮点数的精度问题，需要精确计算时使用 BigDecimal。下一篇文章咱就聊聊新的 macOS 渲染管道，看看怎么利用 Metal 框架提升图形性能。兄弟们有啥问题随时问，鹏磊会尽量解答。