同步语句-创建对象以提供锁，因此c1的更新不会与c2的更新交织

Question

I'm new to Java and is trying to learn the concept of Synchronized statements. I saw the paragraph and the code below from Java Tutorial Oracle. My question is

1) Under what kind of circumstances does update of c1 interleaves with update of c2.

2) How does the object 'lock1' and 'lock2' prevent update of c1 interleaves with the update of c2.

I'm really struggling to understand the concept.

Synchronized statements are also useful for improving concurrency with fine-grained synchronization. Suppose, for example, class MsLunch has two instance fields, c1 and c2, that are never used together. All updates of these fields must be synchronized, but there's no reason to prevent an update of c1 from being interleaved with an update of c2 — and doing so reduces concurrency by creating unnecessary blocking. Instead of using synchronized methods or otherwise using the lock associated with this, we create two objects solely to provide locks.

public class MsLunch {
    private long c1 = 0;
    private long c2 = 0;
    private Object lock1 = new Object();
    private Object lock2 = new Object();

    public void inc1() {
        synchronized(lock1) {
            c1++;
        }
    }

    public void inc2() {
        synchronized(lock2) {
            c2++;
        }
    }
}

Answer 1

When you have a synchronized method :

public synchronized void inc1() {
        c1++;
}

It is implicitly converted to :

public void inc1() {
    synchronized(this) {
        c1++;
    }
}

SO, if you make both inc1 and inc2 synchronized methods, then they both need to get hold of the current object ( this ) monitor and then increment .

But since c1++ and c2++ are independent, they should not be blocked because we are using a single lock. What we must ensure is that multiple calls to inc1() and inc2() should be blocked in seperate sandboxed ways ie, an access to inc1() by thread 1 should not block access to inc2() by thread-2. Having different locks will do this.

Answer 2

The implication is that there might be other threads using the same MsLunch object. For example, you might start two threads like so:

MsLunch ml = new MsLunch();

Thread thread1 = new Thread() {
    public void run() { while (true) ml.inc1(); }
};

Thread thread2 = new Thread() {
    public void run() { while (true) ml.inc2(); }
};

thread1.start();
thread2.start();

There are now two threads running in parallel, one that calls inc1() in a loop and another that calls inc2() in a loop.

By having separate locks for these two methods the two threads won't slow each other down. If you had a shared lock then inc1() and inc2() wouldn't be able to run at the same time. Any time you called one the other would block until the first call finished.

Thread thread3 = new Thread() {
    public void run() { while (true) ml.inc2(); }
};

Contrast this to what happens if you add a third thread that also calls inc2() . Thread #1 is free to call inc1() as fast as it likes. Meanwhile, threads #2 and #3 both want to call inc2() , so they will fight each other to do so. If thread #2 is calling inc2() then thread #3 will block until that call finishes. And vice versa, if thread #3 is in the middle of a call then thread #2 will have to wait.