Thread.sleep和before-before之间有什么关系?

我编写了一个简单的应用程序，它具有主线程(生产者)和多个使用者线程.我想广播来自主线程的消息，因此所有使用者线程都将收到该消息. 但是，我有麻烦. 我试图了解 Thread.sleep 可能与

I've written a simple application, which has main thread(producer) and multiple consumer threads. I want to broadcast a message from main thread, so all the consumer threads will receive it. However, I have troubles. I'm trying to understand how Thread.sleep may be related to Happens-Before. Here's my piece of code:

import java.util.*;

public class PubSub {

    public static void main(String[] args) {
        List<Consumer> consumers = new ArrayList<>();

        for (int i = 0; i < 3; i++ ) {
            Consumer consumer = new Consumer(
                    "Consumer"  + i
            );
            consumer.start();

            consumers.add(consumer);
        }

        Scanner scanner = new Scanner(System.in);

        while(true) {
            String message = scanner.nextLine();

            for (Consumer consumer: consumers) {
                consumer.notify(message);
            }

        }
    }

    static class Consumer extends Thread {

        private Queue<String> queue;

        public Consumer(String name) {
            super(name);
            this.queue = new LinkedList<>();
        }

        @Override
        public void run() {
            while(true) {

                if (!queue.isEmpty()) {
                    String message = queue.poll();

                    System.out.println(
                            getName() + ": Consuming message: " + message
                    );
                }
            }
        }

        public void notify(String message) {
            queue.add(message);
        }
    }

}

如果我添加睡眠，则消费者将开始接收消息:

If I add sleep, the consumer will start receiving messages:

@Override
public void run() {
    while(true) {

        try {
            Thread.sleep(0);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        if (!queue.isEmpty()) {
            String message = queue.poll();

            System.out.println(
                    getName() + ": Consuming message: " + message
            );
        }
    }
}

由于Thread.sleep是本机方法，所以我想了解它是如何解决事前发生的.

Since Thread.sleep is a native method, I want to understand how it resolves happens-before.

我必须注意，修复之前发生的真正方法是使 volatile 关键字:

I must note, that the true way of fixing happens-before is to make volatile keyword:

private volatile Queue<String> queue;

如果将同步添加到队列，它还将解决此问题:

If you add synchronization onto the queue, it will also fix the issue:

@Override
public void run() {
    synchronized (queue) {
        while (true) {

            if (!queue.isEmpty()) {
                String message = queue.poll();

                System.out.println(
                        getName() + ": Consuming message: " + message
                );
            }
        }
    }
}