If a method is called from within a synchronized method, is the inner method's access to shared mutable data thread-safe?

Question

I have a top-level service which has a method A, which accesses shared data and is declared synchronized. Method A in turn calls method B of an internal class, which accesses some shared data of its own.

If I can guarantee that B is only called from the API of the top level service and is not publicly exposed, do I still need to declare B as synchronized? Or is the synchronized declaration of A enough to ensure that B is thread-safe too?

Is there a performance penalty in declaring B synchronized as well?

Answer 1

The key really is that B is not called from somewhere else. As long as this is ensured, you are fine.

There is a small performance penalty if you make B synchronized as well.

Answer 2

Yes, you will be fine.

syncronized(object) {
    do thing one;
    do thing two;
}

is the same as

syncronized(object) {
    doSomething();
}

void doSomething() {
    do thing one;
    do thing two;
}

as long as a lock is held on the object , everything that goes inside the syncronized block will be an atomic operation