Initialize static variable with non-static member variable exactly once

I want to count the number of running RunInAThread instances using https://micrometer.io/docs/concepts#_gauges. From the docs, it is best to either create a gauge on a collection (which I dont have), or use something like AtomicInteger.

However, I need a static instance of an AtomicInteger, and it must be initialized using the MeterRegistry which is a member variable. What is the best practice to do this? I don't want to go for a standard singleton pattern as this would mean I always have to call getInstance() to get the AtomicInteger instance and this would have to be synchronized every time.

Is there any better way than I'm doing right now?

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   
    }

}

synchronized(this) in a constructor is completely useless. that means: Avoid running the code contained in my braces simultaneously with any other thread that locks on the same object. And that object you are locking on? Is by definition not something any other thread could possibly have - you were just created*.

It sounds like this MeterRegistry concept is itself a singleton. Maybe investigate if you can just init that GAUGE once during some other static block. But, if that seems difficult or impossible, then you could use double locking if you really want to squeeze performance out of it; I doubt it matters, though. synchronized is pretty fast. Anyway, this should be even faster in theory:

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(...);
            }
        }
    }
}

This does a few things:

1. The lock is actually useful. There is only one GAUGE_LOCK object in the VM, so if we do hit that synchronized, it'll work. The synchronized also establishes comes-before, thus guaranteeing that the VM will ensure our view of the GAUGE variable is updated; therefore, there is no need to make GAUGE volatile.
2. If we are lucky and the GAUGE variable has been updated, for any reason, then we never synchronize.
3. It is still, due to the second nullcheck, impossible for GAUGE to ever be anything other than either [A] null, or [B] the return value of the one time, ever, we call registry.
4. This is called 'double checked locking'. The two null checks are crucial.

*) You can make synchronized(this) in a constructor actually have an effect, but only if you either fire off a thread within your own constructor, or let your this ref escape from your constructor. These are both such preposterously bad things to do, that I feel justified in assuming you won't do something that daft. At which point we can simplify to: synchronized(this) in a constructor is useless.

Your current synchronized call isn't doing what you think. Synchronizing on 'this' won't prevent two instances of RunInAThread from being instantiated at the same time and both detecting GAUGE as null and setting it.

From your code example it isn't clear why GAUGE has to be static. It is coming from registry and it isn't clear that there are any guarantees that two different registry objects will return the same AtomicInteger. Now if MeterRegistry is a singleton than one option would be use the singleton. Something like:

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

edit
Imagine the code:

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

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

In that case is it really the intention that the same GAUGE would be used in both cases?

Thinking about this some more the previous solution of making the registry a singleton still stands. Alternatively, instead pass in the atomic integer and treat it as a member variable. That would be much more clear and not prone to unexpected behavior.

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

I think that the key is that you are trying to solve this a level below where you should be.