并行运行相同方法时，使用静态方法会影响性能吗？

Question

我有一个 util 类，带有一个私有构造函数，并且所有方法都是静态的。原因是，没有一个方法共享任何对象，因为该类不存储任何状态。但是我想知道如果这些静态方法并行调用，是否会导致任何请求阻塞？静态变量存储在共享内存位置这一事实是否会影响这一点？ 对于理解底层执行机制的任何帮助将不胜感激。

下面是我正在谈论的课程。

public final class PersonUtil {
    private static IPerson person;

    private PersonUtil() {
    }

    public static PersonOutput generatePerson(final PersonInput personInput) {
        if (isParamProvided()) {
            person = new MyPerson();
        } else {
            person = new LegacyPerson();
        }
        return person.create(personInput);
    }

    public static void assignState(final String guid) {
      //call AssignState API for given guid
    }

    public static String getGuidForId(final String id) {
        //call GetGuid API for the given ID
    }

    public static String getPersonNameByGuid(final String guid) {
        // call DescribePerson API
    }
}

Answer 1

是的，你在这里调用generatePerson时可能会遇到并发问题，因为这个方法会影响静态字段person。

假设你有两个线程：

• 使用导致person = new MyPerson() 的参数调用generatePerson
• 另一个调用generatePerson 的参数导致person = new LegacyPerson()

如果两个线程都是并发的，那么可能会发生：

1. 第一个线程集person = new MyPerson()
2. 设置person = new LegacyPerson() 之后的第二个线程
3. 第一个线程在person 上调用create()，即LegacyPerson（因为线程2 在前面的语句中设置了它），但它应该在MyPerson 的实例上调用它李>

为避免这种情况，您应该将person 声明为volatile（这将确保所有线程在读取变量时看到相同的内容），然后您应该将generatePerson 声明为同步，这样一次只能访问一个线程：

private static volatile IPerson person;

public static synchronized PersonOutput generatePerson(final PersonInput personInput) {
    if (isParamProvided()) {
        person = new MyPerson();
    } else {
        person = new LegacyPerson();
    }
    return person.create(personInput);
}

如果MyPerson 和LegacyPerson 不保持任何状态，则可能会有更好的解决方案。如果是这种情况，那么您可以将两个实例声明为final：

private static final IPerson myPerson = new MyPerson();
private static final IPerson legacyPerson = new LegacyPerson();

所以你改变 createPerson 方法来做到这一点：

public static PersonOutput createPerson(final PersonInput personInput) {
    if (isParamProvided()) {
        return myPerson.create(personInput);
    } else {
        return legacyPerson.create(personInput);
    }
} 

这样，您永远不会同时编写静态字段，因此您的静态方法与并发问题无关。

注意：我在createPerson 上提供示例，因为它是您显示代码的唯一方法。您应该在所有 API 端点上应用相同的逻辑，而不会看到我们无法知道是否存在其他并发问题的代码。

建议：尽可能避免并发。它始终是不稳定问题的根源，仅在绝对必要时才应使用。在我提供的第二个示例中，您正在避免它，请尝试在其他端点中执行相同的操作。

Answer 2

您不会遇到性能问题。如果您没有synchronized 块或synchronized 方法，则不会有任何性能问题。

您很可能会遇到并发问题。如果不同线程同时生成多个人，则只会将一个人分配到该字段，您将无法预测女巫。

更糟糕的是，被分配的人可能会随着时间的推移而被替换，而没有任何明确的分配（见下一段）。

您肯定会遇到可见性问题。如果一个线程分配了静态字段person，那么它在某个时间（可能是微秒或分钟）对另一个线程不可见。将人员定义为volatile 以避免它。

private static volatile IPerson person;

当然，您必须确保 MyPerson 和 LegacyPerson 类是线程安全的。这两个类的所有字段必须是final 或volatile。如果无法达到，您将需要 synchronized 块，包括相关的性能缺陷。