Java compiler should check if wait() and notify()

Question

wait(), notify(), and notifyAll() methods should be called within a critical section, but the Java compiler does not check for this. It is usually during running that an Exception is thrown when the methods was not called within a critical section.
To me, it seems that the compiler should check and enforce that wait(), notify() and notifyAll() be called within a critical section.

Answer 1

I think I mis-understood you.
Yes, you are right to say that because callNotify() was called within a critical section at some time, and may be called from other non-critical sections, so the compiler does not have means to keep trace of the calling stack.
How about this:
Because critical sections are always marked by the synchronized keyword, the compiler can actually keep count of the synchronized word and its corresponding braces, then when a wait(), or notify(), or notifyAll() call is made at certain point, the compiler just check for the nested synchronized cunt number, if it is non-zero, it will be syntaxically correct.
Take the example of your code, I see that the proper point for
public class Test {
  Object lock = new Object();
  public void lockObject() {
    synchronized (lock) {
      callNotify();                     // here the synchronized brace count is 1, so it is OK!
  private void callNotify() {
    lock.notify();               // here the synchronized brace count is 0,
                                        // but because it is a stand alone function, the compiler
                                        // can deliver warning information.
  public void dumbMethod() {
    callNotify();              // should deliver warning
  public static void main(String[] args) {
    Test t = new Test();
    t.lockObject();
    t.callNotify();                   // but here, the synchronized brace count is 0, so failure!
}