可以在Java中简化此并发代码

Question

I have the following use case: my Android application makes multiple concurrent HTTP requests to the server. If a request produces "Incorrect token" error then the application should regenerate the token by making a special request to the server and repeat the failed request.

As there are multiple concurrent requests that produce the same error and token should be generated only once I used the following construct:

static final AtomicBoolean isTokenSync = new AtomicBoolean(false);
private static CountDownLatch countDownLatchTokenSync;

if (isTokenSync.compareAndSet(false, true)) {
        countDownLatchTokenSync = new CountDownLatch(1);

        generateAndSaveToken(...);

        isTokenSync.set(false);   
        countDownLatch.countDown();
    }
    else {
        try {
            countDownLatch.await(5, TimeUnit.MINUTES);
        } catch (InterruptedException e) {
        }
    }
}

// repeat the request

Basically first thread gets through and generates the token and other threads wait until token generated and proceed. Is my code a good approach to achieve the behavior? Can it be simplified?

Answer 1

You can use a Phaser here nicely. It's like a CyclicBarrier that supports a dynamic number of waiting parties for all threads arriving at a phase.

static final AtomicBoolean isTokenSync = new AtomicBoolean(false);
private static final Phaser phaser = new Phaser(1);

int phase = phaser.getPhase();
if (isTokenSync.compareAndSet(false, true)) {  

        generateAndSaveToken(...);

        phaser.arrive();
        isTokenSync.set(false);   
    }
    else {
        try {
            phaser.awaitAdvance(phase);
        } catch (InterruptedException e) {
        }
    }
}

Each time you arrive you will increment the phase count. So let's say your start the method at phase == 1 the arrive will increment phase to 2 and all phases less than the current phase will advance.

Answer 2

It looks like you are looking for a Singleton .

See here for a good answer.

Something like this should work.

public static class SingletonToken {

    private final String theToken;

    private SingletonToken() {
        // Do your generateAndSaveToken(...) here.
        theToken = "My token";
    }

    private static class SingletonHolder {

        // The constructor is in a static so will be called only once.
        private static final SingletonToken instance = new SingletonToken();
    }

    public static String getToken() {
        // By the time the code gets here the instance has been created.
        return SingletonHolder.instance.theToken;
    }
}

This essentially deferrs synchronisation to the class loader which is - by definition - thread safe.