CountDownLatch同步

Question

I have a method getNewA() that is supposed to block until some other thread calls setA(x). Is it correct to use a CountDownLatch? I noticed that there is a data race in that there is a possibility that after gate.await() unblocks another thread will call setA(x) using the old latch, therefore it might be possible to miss a value. I thought about synchronizing getNewA() but wouldn't that result in a deadlock? Any suggestions on how to approach this?

package test;

import java.util.concurrent.CountDownLatch;

public class A {

    private int a;
    private CountDownLatch gate;

    public A(int a) {
        a = 1;
        gate = new CountDownLatch(1);
    }

    A getNewA() throws InterruptedException {  // wait for new a...
        gate.await();

        gate = new CountDownLatch(1);
        return this;
    }

    public synchronized int getA() {
        return a;
    }

    public synchronized void setA(int a) {      
        gate.countDown();
        this.a = a;
    }
}

Answer 1

Use a Phaser . You can reuse it just like you want here without having to create a new instance of the your barrier.

public class A {

    private int a
    private final Phaser phaser = new Phaser(1);


    public A(int a) {
        a = 1;
    }


    A getNewA() throws InterruptedException {  // wait for new a...
        phaser.awaitAdvance(phaser.getPhase());
        return this;
    }

    public synchronized  int getA() {
        return percent;
    }

    public synchronized void setA(int a) {      
        this.a = a
        phaser.arrive();
    }
}

Each time setA is called it will increment to a new phase and the phaser.awaitAdvance(phaser.getPhase()) will return out. At this point the new phase will equal the phaser.getPhase()+1

Note: this requires Java 7.

Answer 2

An alternative is to handle synchronization yourself. What I think you want is for the getA to return a value that is set after a thread currently enters. You can use this as the wait() criteria.

public class A {

    private int a;
    private long updateCount = 0;

    private final Object lock = new Object();

    public A getNewA() throws InterruptedException {  // wait for new a...
        synchronized(lock) {
           long currentCount = updateCount ;
           while (currentCount == updateCont) {//assumes never decrementing
              lock.wait();
           }
           return this;
        }
    }

    public int getA() {
        synchronized(lock) {
             return a;
        }
    }

    public void setA(int a) {      
        synchronized(lock) {
             this.a = a;
             updateCount++;
             lock.notifyAll();
        }
    }
}

Edit: Race condition is possible as TomAnderson mentioned. Thanks

Answer 3

You could use a Semahore :

package test;

import java.util.concurrent.Semaphore;

public class A {

    private int a
    private Semaphore semaphore = new Semaphore(0);


    public A(int a) {
        a = 1;            
    }


    A getNewA() throws InterruptedException {  // wait for new a...
        semaphore.acquire();
        return this;
    }

    public synchronized int getA() {
        return percent;
    }

    public synchronized void setA(int a) {                  
        this.a = a;
        semaphore.release();
    }
}

If the semaphore has 0 permits left and two threads call getA one after the other, both will block and only of them will be non-deterministically chosen to wake up when setA is called.

If setA is called twice in a sequence, it will allow two threads to call getA next time, which may not be what you want, since both of them will get the same reference to this .