多线程：为什么输出这个？这是确定性的吗？

Question

我正在学习编写更好的多线程程序，线程安全和确定性。 我遇到了这段代码

// File Name : Callme.java
// This program uses a synchronized block.
  class Callme {
     void call(String msg) {
        System.out.print("[" + msg);
        try {
           Thread.sleep(1000);
        } catch (InterruptedException e) {
           System.out.println("Interrupted");
        }
        System.out.println("]");
     }
  }

  // File Name : Caller.java
  class Caller implements Runnable {
     String msg;
     Callme target;
     Thread t;
     public Caller(Callme targ, String s) {
        target = targ;
        msg = s;
        t = new Thread(this);
        t.start();
     }

     // synchronize calls to call()
     public void run() {
        synchronized(target) { // synchronized block
           target.call(msg);
        }
     }
  }
  // File Name : Synch.java
  public class Synch {
     public static void main(String args[]) {
        Callme target = new Callme();
        Caller ob1 = new Caller(target, "Hello");
        Caller ob2 = new Caller(target, "Synchronized");
        Caller ob3 = new Caller(target, "World");

        // wait for threads to end
        try {
           ob1.t.join();
           ob2.t.join();
           ob3.t.join();
        } catch(InterruptedException e) {
           System.out.println("Interrupted");
        }
     }
  }

产生以下输出（尝试了~100次）

[Hello]
[World]
[Synchronized]

所以我的第一个问题是， 这个输出是否有保证？ 我还观察到，如果我将睡眠改为100它仍会产生相同的输出，但如果我将睡眠改为10则输出变为

[Hello]
[Synchronized]
[World]

第二个问题是， 如果有保证，为什么？ 最后但并非最不重要， 为什么这个输出？ 我期待它

[Hello]
[Synchronized]
[World]

Answer 1

我想这里有两个非常有趣的事情。

代码尝试依赖同步块来保持调用的顺序一致。 这有两个问题：

1）同步块不公平（请参阅同步与锁定 ），因此，首先获得锁定同步块的线程可能不是第一个被授予对象访问权限的块。 然而，根据该帖子，方法级别的同步void synchronized run（）将是一个公平的锁定（在Java 1.5中，而不是Java 1.6），因此等待锁定的第一个将是第一个授予对象的访问权限。

2）即使同步块是公平的，理论上第一个线程可能不是（[synchronized]）可能不是第一个在run（）中调用某些代码的线程。 [世界]实际上可以先称之为。

Answer 2

不，输出不保证。

Answer 3

没有保证输出顺序; 输出是完全随机的，因为它由OS决定，线程应该在一定的时间内分配CPU。 将线程时间分配给CPU的算法是非确定性的。

要使代码按此顺序打印Hello，Synchronized，World，您应该将Synch更改为：

Caller ob1 = new Caller(target, "Hello");
ob1.t.join();
Caller ob2 = new Caller(target, "Synchronized");
ob2.t.join();
Caller ob3 = new Caller(target, "World");
ob3.t.join();

此外，不需要synchronized块（以它的编写方式），因为只有一个线程将调用run方法; msg只是读取，不写入导致任何问题，并且target上的call方法不会以任何方式改变target的状态。

Answer 4

输出的顺序无法保证。 synchronized块可防止不同的线程在打印输出时进行交错 ，但它无法确保三种不同输出的任何顺序。 不幸的是，您所看到的“确定性”行为只是机会。