public class ThreadTest implements Runnable{

    @Override

    public void run() {

        try {

            Thread.sleep(1000L);

        } catch (InterruptedException e) {

            e.printStackTrace();

        }

    }

}

/**

     * 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.

     */

    // BEGIN Android-changed: Implement sleep() methods using a shared native implementation.

    public static void sleep(long millis) throws InterruptedException {

        sleep(millis, 0);

    }

private synchronized void test() throws InterruptedException {
    Thread thread = new Thread();
    //使当前线程无限等待
    thread.wait();
    //使当前线程停止执行1000毫秒
    thread.wait(1000);
    //使当前线程停止执行1000毫秒 + 500纳秒
    thread.wait(1000, 500);
}

/**

     * 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 (<condition does not hold>)

     *             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.

     *

     * @throws  IllegalMonitorStateException  if the current thread is not

     *               the owner of the object's monitor.

     * @throws  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);

    }

/**

     * Wakes up a single thread that is waiting on this object's

     * monitor. If any threads are waiting on this object, one of them

     * is chosen to be awakened. The choice is arbitrary and occurs at

     * the discretion of the implementation. A thread waits on an object's

     * monitor by calling one of the {@code wait} methods.

     * <p>

     * The awakened thread will not be able to proceed until the current

     * thread relinquishes the lock on this object. The awakened thread will

     * compete in the usual manner with any other threads that might be

     * actively competing to synchronize on this object; for example, the

     * awakened thread enjoys no reliable privilege or disadvantage in being

     * the next thread to lock this object.

     * <p>

     * This method should only be called by a thread that is the owner

     * of this object's monitor. A thread becomes the owner of the

     * object's monitor in one of three ways:

     * <ul>

     * <li>By executing a synchronized instance method of that object.

     * <li>By executing the body of a {@code synchronized} statement

     *     that synchronizes on the object.

     * <li>For objects of type {@code Class,} by executing a

     *     synchronized static method of that class.

     * </ul>

     * <p>

     * Only one thread at a time can own an object's monitor.

     *

     * @throws  IllegalMonitorStateException  if the current thread is not

     *               the owner of this object's monitor.

     * @see        java.lang.Object#notifyAll()

     * @see        java.lang.Object#wait()

     */

    @FastNative

    public final native void notify();