wait方法是Object里面的一个native方法，而sleep是Thread里面的方法，下面分别来看两个方法的源码：

/**
     * 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.
     * 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.
      *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.
     *
**/
public final native void wait() throws InterruptedException;

从官方的注释可以知道，当前线程对要持有当前对象的资源锁，并且当前线程会释放锁。
而且要调用notify唤醒wait的线程时，必须先持有对象的资源锁，从这里可以知道，不管是调用wait或者
notify，都要持有同一个对象的锁。

public void funcWait() {
    synchronized(obj) {
        obj.wait()
}
}

public void funcNotify() {
    synchronized(obj) {
        obj.notify()
}
}

Sleep

    /**
     * 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 void sleep(long millis) throws InterruptedException {
        Thread.sleep(millis, 0);
    }

    @FastNative
    private static native void sleep(Object lock, long millis, int nanos)
        throws InterruptedException;

发现官方注释上面，sleep的时候是没有 释放资源锁的。这就是跟wait最大的区别.
下面写对应例子验证：

    private Object waitObj = new Object();
    public void funForWait(int id) {
        synchronized(waitObj) {
            Log.e("@@@", "wait  begin   " + id);
            try {
                waitObj.wait();
            }catch (Exception e) {
                e.printStackTrace();
            }
            Log.e("@@@", "wait  end ： " + id);
        }
    }

    public void funForSleep(int id) {
        synchronized(waitObj) {
            Log.e("@@@", "sleep  begin ： " + id);
            try {
                Thread.sleep(2000);
            }catch (Exception e) {
                e.printStackTrace();
            }
            Log.e("@@@", "sleep  end ： " + id);
        }
    }

        for (int  i = 0; i < 4; i++) {
            final int id = i;
            new Thread(new Runnable() {
                @Override
                public void run() {
                    funForWait(id);
                }
            }).start();
        }

上面测试wait和sleep分别输出入下：

wait   
E/@@@: wait  begin   0
E/@@@: wait  begin   1
E/@@@: wait  begin   2
E/@@@: wait  begin   3

sleep:
E/@@@: sleep  begin ： 0
E/@@@: sleep  end ： 0
E/@@@: sleep  begin ： 1
E/@@@: sleep  end ： 1
E/@@@: sleep  begin ： 3
E/@@@: sleep  end ： 3
E/@@@: sleep  begin ： 2
E/@@@: sleep  end ： 2

从上面的输出可以看出，当调用wait的时候，其他线程是可以继续调用funForwait方法并且访问

Log.e("@@@", "wait begin " + id);

而调用sleep的则不行，从这里可以看出，wait的时候，线程是释放了对Object的锁，而sleep却没有，所以

Log.e("@@@", "sleep begin ： " + id);

这段代码当第一个线程进入sleep的时候，其他线程被挂起并且访问不了这段代码，原因是因为当前线程还是持有Object资源锁。

如果想要中断当前正在挂起等待的线程，可以调用

/**
  * <p> If this thread is blocked in an invocation of the {@link
     * Object#wait() wait()}, {@link Object#wait(long) wait(long)}, or {@link
     * Object#wait(long, int) wait(long, int)} methods of the {@link Object}
     * class, or of the {@link #join()}, {@link #join(long)}, {@link
     * #join(long, int)}, {@link #sleep(long)}, or {@link #sleep(long, int)},
     * methods of this class, then its interrupt status will be cleared and it
     * will receive an {@link InterruptedException}.
***
   */
    public void interrupt() {
        if (this != Thread.currentThread())
            checkAccess();

        synchronized (blockerLock) {
            Interruptible b = blocker;
            if (b != null) {
                nativeInterrupt();
                b.interrupt(this);
                return;
            }
        }
        nativeInterrupt();
    }