Question

我想使用https://micrometer.io/docs/concepts#_gauges计算正在运行的RunInAThread实例的数量。从文档中，最好是在集合上创建量规（我没有），或者使用类似AtomicInteger的方法。

但是，我需要一个AtomicInteger的静态实例，并且必须使用作为成员变量的MeterRegistry对其进行初始化。最佳做法是什么？我不想使用标准的单例模式，因为这意味着我总是必须调用getInstance（）来获取AtomicInteger实例，并且每次都必须对其进行同步。

有什么比我现在做的更好的方法吗？

public class RunInAThread implements Runnable {

    private static AtomicInteger GAUGE = null;
    
    public RunInAThread(final MeterRegistry registry) {
        synchronized(this) {
            if(GAUGE==null) {
                GAUGE = registry.gauge("some_name", Collections.emptySet(), new AtomicInteger());
            }
        }     
    }

    @Override
    public void run() {
        GAUGE.incrementAndGet()
        doSomething();
        GAUGE.decrementAndGet()
    }

    private void doSomething() {   
       // processing like a boss in a while loop   
    }

}

Answer 1

synchronized(this)在构造函数中是完全没有用的。这意味着：避免与锁定同一对象的任何其他线程同时运行花括号中包含的代码。而您锁定的那个对象？从定义上说，其他任何线程都不可能拥有-您刚刚创建*。

听起来MeterRegistry这个概念本身就是一个单例。也许研究一下是否可以在其他静态块中一次初始化该GAUGE。但是，如果这看起来困难或不可能，那么如果您确实想从中挤出性能，则可以使用双重锁定。我怀疑这是否重要。同步非常快。无论如何，理论上这应该更快：

public class RunInAThread implements Runnable {
    private static final Object GAUGE_LOCK = new Object();
    private static AtomicInteger GAUGE = null;
    
    public RunInAThread(final MeterRegistry registry) {
        if (GAUGE == null) {
            synchronized (GAUGE_LOCK) {
                if (GAUGE == null) GAUGE = registry.gauge(...);
            }
        }
    }
}

这可以做一些事情：

该锁实际上很有用。 VM中只有一个GAUGE_LOCK对象，因此，如果我们确实实现了同步，则它将起作用。同步也会先建立，从而确保VM将确保更新我们对GAUGE变量的视图；因此，无需使GAUGE易变。
如果幸运的话，无论出于任何原因，GAUGE变量都已更新，那么我们就永远不会同步。
由于第二次nullcheck的存在，GAUGE仍然不可能是[A] null或[B]一次的返回值以外的任何东西，我们称之为注册表。
这称为“双重检查锁定”。这两个空检查至关重要。

*）您可以使构造函数中的synchronized(this)实际上起作用，但前提是您必须在自己的构造函数中触发一个线程，或者让this引用从构造函数中逸出。这些都是非常荒谬的事情，我以为假设您不会做一些愚蠢的事情是合理的。在这一点上，我们可以简化为：synchronized(this)在构造函数中是没有用的。

Answer 2

您当前的同步呼叫没有按照您的想法进行。在“ this”上进行同步不会阻止同时实例化两个RunInAThread实例，并且不会检测到GAUGE为null并将其设置为空。

从您的代码示例中尚不清楚为什么GAUGE必须是静态的。它来自注册表，尚不清楚是否可以保证两个不同的注册表对象将返回相同的AtomicInteger。现在，如果MeterRegistry是一个单例，则可以使用一个选项。像这样：

private static final AtomicInteger GAUGE = MeterRegistry.getInstances().gauge(...)

编辑想象一下代码：

MeterRegistry reg1 = new MeterRegistry(...);
RunInAThread thread1 = RunInAThread(reg1)

MeterRegistry reg2 = new MeterRegistry(...);
RunInAThread thread2 = RunInAThread(reg1)

在那种情况下，是否真的打算在两种情况下使用相同的GAUGE？

对此进行更多思考，以前使注册表成为单例的解决方案仍然有效。另外，也可以传入原子整数并将其视为成员变量。这样会更清楚，而且不会出现意外行为。

MeterRegistery reg = new MeterRegistry(...);
AtomicInteger gauge = reg.gauge(...);
RunInAThread thread1 = RunInAThread(gauge);
RunInAThread thread2 = RunInAThread(gauge);

我认为关键是您正在尝试在低于应有的水平上解决这个问题。

一次用非静态成员变量初始化静态变量

2 个答案: