Java中的同步块如何工作？ 变量引用或内存被阻止？

Question

I have a situation and I need some advice about synchronized block in Java. I have a Class Test below:

Class Test{
    private A a;
    public void doSomething1(String input){
        synchronized (a) {
            result = a.process(input);
        }
    }
    public void doSomething2(String input){
        synchronized (a) {
            result = a.process(input);
        }
    }
    public void doSomething3(String input){
            result = a.process(input);
    }
}

What I want is when multi threads call methods doSomeThing1() or doSomeThing2() , object "a" will be used and shared among multi threads (it have to be) and it only processes one input at a time (waiting until others thread set object "a" free) and when doSomeThing3 is called, the input is processed immediately.

My question is will the method doSomeThing3() be impacted my method doSomeThing1() and doSomeThing2() ? Will it have to wait if doSomeThing1() and doSomeThing2() are using object "a"?

Answer 1

A method is never impacted by anything that your threads do. What gets impacted is data , and the answer to your question depends entirely on what data are updated (if any) inside the a.process() call.

You asked "Variable reference or memory is blocked?"

First of all, "variable" and "memory" are the same thing. Variables, and fields and objects are all higher level abstractions that are built on top of the lower-level idea of "memory".

Second of all, No. Locking an object does not prevent other threads from accessing or modifying the object or, from accessing or modifying anything else.

Locking an object does two things: It prevents other threads from locking the same object at the same time, and it makes certain guarantees about the visibility of memory updates. The simple explanation is, if thread X updates some variables and then releases a lock, thread Y will be guaranteed to see the updates only after it has acquired the same lock.

What that means for your example is, if thread X calls doSomething1() and modifies the object a; and then thread Y later calls doSomething3(), thread Y is not guaranteed to see the the updates. It might see the a object in its original state, it might see it in the fully updated state, or it might see it in some invalid half-way state. The reason why is because, even though thread X locked the object, modified it, and then released the lock; thread Y never locked the same object.

Answer 2

In your code, doSomething3() can proceed in parallel with doSomething1() or doSomething2(), so in that sense it does what you want. However, depending on exactly what a.process() does, this may cause a race condition and corrupt data. Note that even if doSomething3() is called, any calls to doSomething1() or doSomething2() that have started will continue; they won't be put in abeyance while doSomething3() is processed.