我正在阅读一本关于线程/同步的简单示例，该书声称使用synchronized会允许在同一实例上调用一个线程来访问该方法。它确实按照承诺进行了序列化，但似乎Caller在Synch
main下面的方法中创建的第三个数组的大约9/10倍于第二个数组。该代码是示例代码，显示了没有同步方法的问题。

class CallMe {
    void call(String msg) {
        System.out.print("[" + msg);
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            System.out.println("CallMe Interrupted");
        }
        System.out.println("]");
    }
}

class Caller implements Runnable {
    String msg;
    CallMe target;
    Thread t;

    public Caller (CallMe target, String msg) {
        this.target = target;
        this.msg = msg;
        t = new Thread(this);
        t.start();
    }

    @Override
    public void run() {
        target.call(msg);
    }
}

class Synch {
    public static void main(String args[]) {
        CallMe target = new CallMe();
        Caller c1 = new Caller(target, "Hello");
        Caller c2 = new Caller(target, "Synchronized");
        Caller c3 = new Caller(target, "World");

        try {       
            c1.t.join();
            c2.t.join();
            c3.t.join();        
        } catch (InterruptedException e) {
            System.out.println("Synch Interrupted");
        }
    }
}

这本书说明了两种方式来处理这个问题，他们是-
synchronized void call(String msg) {...}并且
public void run() { synchronized (target) {...} }

很显然，这两种选择工作，因为，相对于原来的代码，括号内的字都像一致…

[您好]
[世界]（大约90％的电话回退时间）
[已同步]（1 /许多已同步为第一个味精）

…原始代码没有韵律或理由。因此，我知道它是“有效的”，可以通过在每个Caller实例上放置断点直接看到它。每当我这样做时，对我来说，它每次都有效。

为什么第三个在第二个之前Caller始终调用call？