Java谜题2：梦境 - 解决方案

package sleep;
 
import dream.Dream;
 
public class Sleeper {
    private int level;
     
    public synchronized int enter(Dream dream) {
        level++;
        try {
            dream.dream(this);
        } finally {
            level--;
        }
        return level;
    }
}

package sleep;
 
import dream.Dream;
 
public class Main {
    public static void main(String[] args) {
        if (new Sleeper().enter(new Dream()) != 0) {
            // The goal is to reach this line
            System.out.println("Am I still dreaming?");
        }
    }
}

解决方案：
synchronized对dream方法意味着当我们进入睡眠对象时，它会获取它的监视器（锁），当我们离开它时，它会再次释放它。当监视器处于保留状态时，没有其他线程可以输入该方法。
但这里有一个问题：在方法运行时，监视器不一定一直保持。使用object.wait，您可以在synchronized方法的中间释放监视器。
我们如何应用它来解决这个难题？当我们进入外部梦境时，我们用 wait来释放监视器。但首先我们启动一个单独的线程，这也将进入一个梦想。进入那个内心的梦想，让第二根线程占据了显示器。所以在内心的梦里，我们用 wait再次来释放监视器。这允许主线程停止等待，取回监视器，并离开外部梦想。我们就在那里：我们已经从外梦中醒来，回到了我们开始的地方，但是梦中的梦在第二个线程中继续。

package dream;
 
import sleep.Sleeper;
 
public class Dream {
    private static void doWait(Sleeper s) {
        try {
            s.wait(200);
        } catch (InterruptedException e) {
        }
    }
     
    public void dream(final Sleeper s) {
        new Thread() {
            public void run() {
                s.enter(new Dream() {
                    @Override
                    public void dream(Sleeper s) {
                        doWait(s);
                    }
                });
            }
        }.start();
         
        doWait(s);
    }
}

结论
故事的寓意：synchronized在一个方法上并不意味着两个不同的线程不能同时在其中。它只能确保这些线程不能并发执行; 至少其中之一必须等待。
您可以使用私有对象作为监视器来防止此类滥用和其他问题：

public class Sleeper {
    private final Object lock = new Object();
     
    public int dream(Dream dream) {
        synchronized(lock) {
            ...
        }
    }
}