Java and thread safety

Question

I am creating a mutli threaded application, and I have a question regarding the use of synchronized methods.

Lets say I have the following component which would be accessed by multiple threads.

Component.java

public class Component {
    private boolean active;

    //Constructor
    public Component(){
        active = false;
    }

    synchronized public void initiate(){
        //do something
        active = true;
    }

    synchronized public void closedown(){
        //do something
        active = false;
    }

    public void doSomething(){
        //do something
    }

    public boolean isActive(){
        return active;
    }
}

If I have two threads accessing the the same Component object and the first thread gets halted in the Component.closedown() before it has set active = false, and the second thread picks up and calls Component.isActive(), will the second thread block until the first thread has finished the closedown, or will it get the returned value of true?

If it is the latter, how can I make this thread safe?

Answer 1

Yes, that is the essence of mutual-exclusion locks (mutexes). If a thread gets descheduled by the OS while holding a mutex, all other threads requiring the mutex to proceed will be stalled.

The above is actually the reason why, even if we take care to make all our critical sections very short and fast to execute, mutexes will still cause occasional latency spikes, and the spikes will be huge in proportion to regular latency. For example, your simple getter will execute in a couple of nanoseconds when uncontended, but may take 10µs or more if the thread holding the mutex is descheduled at an inconvenient time.

NOTE: The code in your question lacks the synchronized designation on isActive, but I assume your question is about what would happen if it was synchronized—because the code has a data race without it. Specifically:

will the second thread block until the first thread has finished the closedown, or will it get the returned value of true?

Without synchronized it will do neither: it won't block, but it won't be guaranteed to ever return the true value. You are only guaranteed to observe the initial value (that's what the data race is about).

If you are looking for a practical advice to improve your code, then don't synchronize isActive method, but make the active flag volatile. This is standard practice for your use case.

Answer 2

You need to have use a lock to protect the critical sections. As some methods read from the value and some write to the value, you can try using a ReadWriteLock.

public class Component {
    private final ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();
    private boolean active;

    //Constructor
    public Component(){
        active = false;
    }

    public void initiate(){
        // non-critical section
        rwl.writeLock().lock();
        try {
            // critical section
            active = true;
        } finally {
            rwl.writeLock().unlock();
        }
    }

    public void closedown(){
        // non-critical section
        rwl.writeLock().lock();
        try {
            // critical section
            active = false;
        } finally {
            rwl.writeLock().unlock();
        }
    }

    public void doSomething(){
        // do something
    }

    public boolean isActive(){
        rwl.readLock().lock();
        boolean status = active;
        rwl.readLock().unlock();
        return status;
    }
}