允许JVM假设其他线程在循环过程中不更改PizzaArrived变量。 换句话说，它可以将PizzaArrived==false测试挂起到循环之外，从而对此进行优化:

while (pizzaArrived == false) {}

变成这个:

if (pizzaArrived == false) while (true) {}

这是一个无限循环。

为了确保一个线程所做的更改对其他线程是可见的，您必须始终在线程之间添加一些同步。 最简单的方法是使共享变量volatile:

volatile boolean pizzaArrived = false;

使变量volatile保证了不同的线程将看到彼此对它的更改所产生的影响。 这可以防止JVM缓存PizzaArrived的值或将测试提升到循环之外。 相反，它每次都必须读取实变量的值。

（更正式地说，volatile在对变量的访问之间创建了happers-before关系。这意味着线程在交付pizza之前所做的所有其他工作对于接收pizza的线程也是可见的，即使这些其他更改不是针对volatile变量的。）

同步方法主要用于实现互斥（防止两件事同时发生），但它们也具有与volatile相同的副作用。 在读写变量时使用它们是使更改对其他线程可见的另一种方法:

class MyHouse {
    boolean pizzaArrived = false;

    void eatPizza() {
        while (getPizzaArrived() == false) {}
        System.out.println("That was delicious!");
    }

    synchronized boolean getPizzaArrived() {
        return pizzaArrived;
    }

    synchronized void deliverPizza() {
        pizzaArrived = true;
    }
}

System.Out是一个PrintStream对象。 PrintStream的方法是这样同步的:

public void println(String x) {
    synchronized (this) {
        print(x);
        newLine();
    }
}

同步防止在循环期间缓存PizzaArrived。 严格地说，两个线程必须在同一个对象上同步，以保证对变量的更改是可见的。 （例如，在设置PizzaArrived之后调用println并在读取PizzaArrived之前再次调用它将是正确的。） 如果在特定对象上只有一个线程同步，则允许JVM忽略它。 在实践中，JVM不够聪明，无法证明其他线程在设置PizzaArrived后不会调用println，因此它假定它们可能会调用。 因此，如果您调用system.out.println，它无法在循环期间缓存变量。 这就是为什么像这样的循环在有print语句时会起作用，尽管这不是一个正确的修复方法。

使用System.out并不是导致这种效果的唯一方法，但它是人们在试图调试循环不工作的原因时最经常发现的方法！

while（pizzaArrived==false){}是忙等待循环。 太糟糕了！ 当它等待时，它会占用CPU，这会减慢其他应用程序的速度，并增加系统的功耗，温度和风扇速度。 理想情况下，我们希望循环线程在等待时休眠，这样它就不会占用CPU。

以下是一些方法:

低级解决方案是使用object的wait/notify方法:

class MyHouse {
    boolean pizzaArrived = false;

    void eatPizza() {
        synchronized (this) {
            while (!pizzaArrived) {
                try {
                    this.wait();
                } catch (InterruptedException e) {}
            }
        }

        System.out.println("That was delicious!");
    }

    void deliverPizza() {
        synchronized (this) {
            pizzaArrived = true;
            this.notifyAll();
        }
    }
}

在这个版本的代码中，循环线程调用wait()，这使线程进入睡眠状态。 它在休眠时不会使用任何CPU周期。 在第二个线程设置变量之后，它调用notifyAll()来唤醒正在等待该对象的任何/所有线程。 这就像让送披萨的人按门铃，这样你就可以在等待的时候坐下来休息，而不是尴尬地站在门口。

当对一个对象调用wait/notify时，您必须持有该对象的同步锁，上面的代码就是这样做的。 只要两个线程都使用相同的对象，您就可以使用您喜欢的任何对象:这里我使用了this(MyHouse的实例）。 通常，两个线程不能同时进入同一个对象的同步块（这是同步目的的一部分），但在这里可以工作，因为线程在wait()方法中时会临时释放同步锁。

BlockingQueue用于实现生产者-消费者队列。 “消费者”从队列前面拿物品，“生产者”在后面推物品。 举个例子:

class MyHouse {
    final BlockingQueue<Object> queue = new LinkedBlockingQueue<>();

    void eatFood() throws InterruptedException {
        // take next item from the queue (sleeps while waiting)
        Object food = queue.take();
        // and do something with it
        System.out.println("Eating: " + food);
    }

    void deliverPizza() throws InterruptedException {
        // in producer threads, we push items on to the queue.
        // if there is space in the queue we can return immediately;
        // the consumer thread(s) will get to it later
        queue.put("A delicious pizza");
    }
}

注意:BlockingQueue的Put和Take方法可以引发InterruptedException，这是必须处理的检查异常。 在上面的代码中，为了简单起见，重新抛出了异常。 您可能更喜欢捕获方法中的异常，然后重试put或take调用以确保它成功。 除了这一点难看之外，BlockingQueue非常容易使用。

这里不需要其他同步，因为BlockingQueue确保线程在将项放入队列之前所做的一切对于取出这些项的线程都是可见的。

executor类似于执行任务的现成blockingqueue。 示例:

// A "SingleThreadExecutor" has one work thread and an unlimited queue
ExecutorService executor = Executors.newSingleThreadExecutor();

Runnable eatPizza = () -> { System.out.println("Eating a delicious pizza"); };
Runnable cleanUp = () -> { System.out.println("Cleaning up the house"); };

// we submit tasks which will be executed on the work thread
executor.execute(eatPizza);
executor.execute(cleanUp);
// we continue immediately without needing to wait for the tasks to finish

有关详细信息，请参阅executor，executorservice和executors的文档。

在等待用户单击UI中的某些内容时循环是错误的。 相反，使用UI工具包的事件处理功能。 例如，在Swing中:

JLabel label = new JLabel();
JButton button = new JButton("Click me");
button.addActionListener((ActionEvent e) -> {
    // This event listener is run when the button is clicked.
    // We don't need to loop while waiting.
    label.setText("Button was clicked");
});

因为事件处理程序在事件分派线程上运行，所以在事件处理程序中执行长时间的工作会阻塞与UI的其他交互，直到工作完成为止。 慢速操作可以在新线程上启动，也可以使用上述技术之一（wait/notify，blockingqueue或executor)分派给等待线程。 您还可以使用SwingWorker，它正是为此而设计的，并自动提供后台工作线程:

JLabel label = new JLabel();
JButton button = new JButton("Calculate answer");

// Add a click listener for the button
button.addActionListener((ActionEvent e) -> {

    // Defines MyWorker as a SwingWorker whose result type is String:
    class MyWorker extends SwingWorker<String,Void> {
        @Override
        public String doInBackground() throws Exception {
            // This method is called on a background thread.
            // You can do long work here without blocking the UI.
            // This is just an example:
            Thread.sleep(5000);
            return "Answer is 42";
        }

        @Override
        protected void done() {
            // This method is called on the Swing thread once the work is done
            String result;
            try {
                result = get();
            } catch (Exception e) {
                throw new RuntimeException(e);
            }
            label.setText(result); // will display "Answer is 42"
        }
    }

    // Start the worker
    new MyWorker().execute();
});

要执行定期操作，可以使用java.util.timer。 它比编写自己的计时循环更容易使用，并且更容易启动和停止。 此演示程序每秒打印一次当前时间:

Timer timer = new Timer();
TimerTask task = new TimerTask() {
    @Override
    public void run() {
        System.out.println(System.currentTimeMillis());
    }
};
timer.scheduleAtFixedRate(task, 0, 1000);

每个java.util.timer都有自己的后台线程，用于执行其调度的TimerTask。 自然，线程在任务之间休眠，因此它不会占用CPU。

在Swing代码中，还有一个javax.Swing.timer，与之类似，但它在Swing线程上执行侦听器，因此您可以安全地与Swing组件交互，而不需要手动切换线程:

JFrame frame = new JFrame();
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
Timer timer = new Timer(1000, (ActionEvent e) -> {
    frame.setTitle(String.valueOf(System.currentTimeMillis()));
});
timer.setRepeats(true);
timer.start();
frame.setVisible(true);

如果您正在编写多线程代码，那么值得探索一下这些包中的类，看看有哪些可用的:

• java.util.concurrent
• java.util.concurrent.atomic
• java.util.concurrent.locks

并请参阅Java教程的并发部分。 多线程是复杂的，但有很多帮助可用！