sleep & wait

/**
 * Causes the currently executing thread to sleep (temporarily cease
 * execution) for the specified number of milliseconds, subject to
 * the precision and accuracy of system timers and schedulers. The thread
 * does not lose ownership of any monitors.
 *
 * @param  millis
 *         the length of time to sleep in milliseconds
 *
 * @throws  IllegalArgumentException
 *          if the value of {@code millis} is negative
 *
 * @throws  InterruptedException
 *          if any thread has interrupted the current thread. The
 *          <i>interrupted status</i> of the current thread is
 *          cleared when this exception is thrown.
 */
public static native void sleep(long millis) throws InterruptedException;

/**
 * Causes the current thread to wait until another thread invokes the
 * {@link java.lang.Object#notify()} method or the
 * {@link java.lang.Object#notifyAll()} method for this object.
 * In other words, this method behaves exactly as if it simply
 * performs the call {@code wait(0)}.
 * <p>
 * The current thread must own this object's monitor. The thread
 * releases ownership of this monitor and waits until another thread
 * notifies threads waiting on this object's monitor to wake up
 * either through a call to the {@code notify} method or the
 * {@code notifyAll} method. The thread then waits until it can
 * re-obtain ownership of the monitor and resumes execution.
 * <p>
 * As in the one argument version, interrupts and spurious wakeups are
 * possible, and this method should always be used in a loop:
 * <pre>
 *     synchronized (obj) {
 *         while (&lt;condition does not hold&gt;)
 *             obj.wait();
 *         ... // Perform action appropriate to condition
 *     }
 * </pre>
 * This method should only be called by a thread that is the owner
 * of this object's monitor. See the {@code notify} method for a
 * description of the ways in which a thread can become the owner of
 * a monitor.
 *
 * @exception  IllegalMonitorStateException  if the current thread is not
 *               the owner of the object's monitor.
 * @exception  InterruptedException if any thread interrupted the
 *             current thread before or while the current thread
 *             was waiting for a notification.  The <i>interrupted
 *             status</i> of the current thread is cleared when
 *             this exception is thrown.
 * @see        java.lang.Object#notify()
 * @see        java.lang.Object#notifyAll()
 */
public final void wait() throws InterruptedException {
    wait(0);
}

Object lock = new Object();
synchronized (lock) {
    try {
    	// TODO business logic
        lock.wait(1000);
    } catch (InterruptedException e1) {
        e1.printStackTrace();
    }
}
System.out.println("After wait 1000ms");

new Thread(new Runnable() {
  @Override public void run() {
    System.out.println("[1]execute");
    synchronized (lock) {
      try {
        new Thread(new Runnable() {
          @Override public void run() {
            System.out.println("[2]New Thread executed " + Thread.currentThread());
            synchronized (lock) {
              System.out.println("[2]lock obtained by " + Thread.currentThread());
              try {
                Thread.sleep(5000);
                System.out.println("[2]Job done,release lock " + Thread.currentThread());
                lock.notify();
              } catch (InterruptedException e1) {
                e1.printStackTrace();
              }
            }
          }
        }).start();
        System.out.println("[1]Sleep 1000ms");
        Thread.sleep(1000);
        System.out.println("[1]lock wait 1000");
        lock.wait(1000);
      } catch (InterruptedException e1) {
        e1.printStackTrace();
      }
    }
    System.out.println("[1]After wait 1000ms");
  }
}).start();