diff --git a/src/debugger.cc b/src/debugger.cc
index 158be0b..5240c6c 100644
--- a/src/debugger.cc
+++ b/src/debugger.cc
@@ -1424,6 +1424,7 @@
     case kTerminated:   *pThreadStatus = JDWP::TS_ZOMBIE;   break;
     case kRunnable:     *pThreadStatus = JDWP::TS_RUNNING;  break;
     case kTimedWaiting: *pThreadStatus = JDWP::TS_WAIT;     break;
+    case kSleeping:     *pThreadStatus = JDWP::TS_SLEEPING; break;
     case kBlocked:      *pThreadStatus = JDWP::TS_MONITOR;  break;
     case kWaiting:      *pThreadStatus = JDWP::TS_WAIT;     break;
     case kStarting:     *pThreadStatus = JDWP::TS_ZOMBIE;   break;
@@ -1442,34 +1443,6 @@
     // Don't add a 'default' here so the compiler can spot incompatible enum changes.
   }
 
-  if (thread->GetState() == kTimedWaiting) {
-    // Since Thread.sleep is implemented using Object.wait, see if Thread.sleep
-    // is on the stack and change state to TS_SLEEPING if it is.
-    struct SleepMethodVisitor : public StackVisitor {
-      SleepMethodVisitor(const ManagedStack* stack,
-                         const std::deque<InstrumentationStackFrame>* instrumentation_stack)
-          SHARED_LOCKS_REQUIRED(Locks::mutator_lock_)
-          : StackVisitor(stack, instrumentation_stack, NULL), found_(false) {}
-
-      virtual bool VisitFrame() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
-        std::string name(PrettyMethod(GetMethod(), false));
-        if (name == "java.lang.Thread.sleep") {
-          found_ = true;
-          return false;
-        }
-        return true;
-      }
-
-      bool found_;
-    };
-
-    SleepMethodVisitor visitor(thread->GetManagedStack(), thread->GetInstrumentationStack());
-    visitor.WalkStack(false);
-    if (visitor.found_) {
-      *pThreadStatus = JDWP::TS_SLEEPING;
-    }
-  }
-
   *pSuspendStatus = (thread->IsSuspended() ? JDWP::SUSPEND_STATUS_SUSPENDED : JDWP::SUSPEND_STATUS_NOT_SUSPENDED);
 
   return true;
diff --git a/src/monitor.cc b/src/monitor.cc
index 33383eb..7cdccac 100644
--- a/src/monitor.cc
+++ b/src/monitor.cc
@@ -379,8 +379,11 @@
  * Since we're allowed to wake up "early", we clamp extremely long durations
  * to return at the end of the 32-bit time epoch.
  */
-void Monitor::Wait(Thread* self, int64_t ms, int32_t ns, bool interruptShouldThrow) {
+void Monitor::Wait(Thread* self, int64_t ms, int32_t ns,
+                   bool interruptShouldThrow, ThreadState why) {
   DCHECK(self != NULL);
+  DCHECK(why == kTimedWaiting || why == kWaiting || why == kSleeping);
+  DCHECK(why != kWaiting || (ms == 0 && ns == 0));
 
   // Make sure that we hold the lock.
   if (owner_ != self) {
@@ -388,10 +391,12 @@
     return;
   }
   monitor_lock_.AssertHeld(self);
-  WaitWithLock(self, ms, ns, interruptShouldThrow);
+
+  WaitWithLock(self, ms, ns, interruptShouldThrow, why);
 }
 
-void Monitor::WaitWithLock(Thread* self, int64_t ms, int32_t ns, bool interruptShouldThrow) {
+void Monitor::WaitWithLock(Thread* self, int64_t ms, int32_t ns,
+                           bool interruptShouldThrow, ThreadState why) {
   // Enforce the timeout range.
   if (ms < 0 || ns < 0 || ns > 999999) {
     Thread::Current()->ThrowNewExceptionF("Ljava/lang/IllegalArgumentException;",
@@ -419,12 +424,11 @@
   locking_dex_pc_ = 0;
 
   /*
-   * Update thread status.  If the GC wakes up, it'll ignore us, knowing
+   * Update thread state. If the GC wakes up, it'll ignore us, knowing
    * that we won't touch any references in this state, and we'll check
    * our suspend mode before we transition out.
    */
-  bool timed = (ms != 0 || ns != 0);
-  self->TransitionFromRunnableToSuspended(timed ? kTimedWaiting : kWaiting);
+  self->TransitionFromRunnableToSuspended(why);
 
   bool wasInterrupted = false;
   {
@@ -448,9 +452,10 @@
       wasInterrupted = true;
     } else {
       // Wait for a notification or a timeout to occur.
-      if (!timed) {
+      if (why == kWaiting) {
         self->wait_cond_->Wait(self);
       } else {
+        DCHECK(why == kTimedWaiting || why == kSleeping) << why;
         self->wait_cond_->TimedWait(self, ms, ns);
       }
       if (self->interrupted_) {
@@ -733,7 +738,8 @@
 /*
  * Object.wait().  Also called for class init.
  */
-void Monitor::Wait(Thread* self, Object *obj, int64_t ms, int32_t ns, bool interruptShouldThrow) {
+void Monitor::Wait(Thread* self, Object *obj, int64_t ms, int32_t ns,
+                   bool interruptShouldThrow, ThreadState why) {
   volatile int32_t* thinp = obj->GetRawLockWordAddress();
 
   // If the lock is still thin, we need to fatten it.
@@ -753,7 +759,7 @@
     Inflate(self, obj);
     VLOG(monitor) << StringPrintf("monitor: thread %d fattened lock %p by wait()", self->GetThinLockId(), thinp);
   }
-  LW_MONITOR(*thinp)->Wait(self, ms, ns, interruptShouldThrow);
+  LW_MONITOR(*thinp)->Wait(self, ms, ns, interruptShouldThrow, why);
 }
 
 void Monitor::Notify(Thread* self, Object *obj) {
diff --git a/src/monitor.h b/src/monitor.h
index c3b4b21..977a7f1 100644
--- a/src/monitor.h
+++ b/src/monitor.h
@@ -82,7 +82,7 @@
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
   static void NotifyAll(Thread* self, Object* obj)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-  static void Wait(Thread* self, Object* obj, int64_t ms, int32_t ns, bool interruptShouldThrow)
+  static void Wait(Thread* self, Object* obj, int64_t ms, int32_t ns, bool interruptShouldThrow, ThreadState why)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
   static void DescribeWait(std::ostream& os, const Thread* thread)
@@ -125,9 +125,9 @@
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
 
-  void Wait(Thread* self, int64_t msec, int32_t nsec, bool interruptShouldThrow)
+  void Wait(Thread* self, int64_t msec, int32_t nsec, bool interruptShouldThrow, ThreadState why)
       NO_THREAD_SAFETY_ANALYSIS;
-  void WaitWithLock(Thread* self, int64_t ms, int32_t ns, bool interruptShouldThrow)
+  void WaitWithLock(Thread* self, int64_t ms, int32_t ns, bool interruptShouldThrow, ThreadState why)
       EXCLUSIVE_LOCKS_REQUIRED(monitor_lock_)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
diff --git a/src/native/java_lang_Object.cc b/src/native/java_lang_Object.cc
index bcea373..f3c295e 100644
--- a/src/native/java_lang_Object.cc
+++ b/src/native/java_lang_Object.cc
@@ -18,37 +18,49 @@
 #include "object.h"
 #include "scoped_thread_state_change.h"
 
+// TODO: better support for overloading.
+#undef NATIVE_METHOD
+#define NATIVE_METHOD(className, functionName, signature, identifier) \
+    { #functionName, signature, reinterpret_cast<void*>(className ## _ ## identifier) }
+
 namespace art {
 
-static jobject Object_internalClone(JNIEnv* env, jobject javaThis) {
+static jobject Object_internalClone(JNIEnv* env, jobject java_this) {
   ScopedObjectAccess soa(env);
-  Object* o = soa.Decode<Object*>(javaThis);
+  Object* o = soa.Decode<Object*>(java_this);
   return soa.AddLocalReference<jobject>(o->Clone(soa.Self()));
 }
 
-static void Object_notify(JNIEnv* env, jobject javaThis) {
+static void Object_notify(JNIEnv* env, jobject java_this) {
   ScopedObjectAccess soa(env);
-  Object* o = soa.Decode<Object*>(javaThis);
+  Object* o = soa.Decode<Object*>(java_this);
   o->Notify();
 }
 
-static void Object_notifyAll(JNIEnv* env, jobject javaThis) {
+static void Object_notifyAll(JNIEnv* env, jobject java_this) {
   ScopedObjectAccess soa(env);
-  Object* o = soa.Decode<Object*>(javaThis);
+  Object* o = soa.Decode<Object*>(java_this);
   o->NotifyAll();
 }
 
-static void Object_wait(JNIEnv* env, jobject javaThis, jlong ms, jint ns) {
+static void Object_wait(JNIEnv* env, jobject java_this) {
   ScopedObjectAccess soa(env);
-  Object* o = soa.Decode<Object*>(javaThis);
+  Object* o = soa.Decode<Object*>(java_this);
+  o->Wait();
+}
+
+static void Object_waitJI(JNIEnv* env, jobject java_this, jlong ms, jint ns) {
+  ScopedObjectAccess soa(env);
+  Object* o = soa.Decode<Object*>(java_this);
   o->Wait(ms, ns);
 }
 
 static JNINativeMethod gMethods[] = {
-  NATIVE_METHOD(Object, internalClone, "()Ljava/lang/Object;"),
-  NATIVE_METHOD(Object, notify, "()V"),
-  NATIVE_METHOD(Object, notifyAll, "()V"),
-  NATIVE_METHOD(Object, wait, "(JI)V"),
+  NATIVE_METHOD(Object, internalClone, "()Ljava/lang/Object;", internalClone),
+  NATIVE_METHOD(Object, notify, "()V", notify),
+  NATIVE_METHOD(Object, notifyAll, "()V", notifyAll),
+  NATIVE_METHOD(Object, wait, "()V", wait),
+  NATIVE_METHOD(Object, wait, "(JI)V", waitJI),
 };
 
 void register_java_lang_Object(JNIEnv* env) {
diff --git a/src/native/java_lang_Thread.cc b/src/native/java_lang_Thread.cc
index f14c03b..8db217e 100644
--- a/src/native/java_lang_Thread.cc
+++ b/src/native/java_lang_Thread.cc
@@ -16,6 +16,7 @@
 
 #include "debugger.h"
 #include "jni_internal.h"
+#include "monitor.h"
 #include "object.h"
 #include "scoped_thread_state_change.h"
 #include "ScopedUtfChars.h"
@@ -65,6 +66,7 @@
     case kTerminated:                     return kJavaTerminated;
     case kRunnable:                       return kJavaRunnable;
     case kTimedWaiting:                   return kJavaTimedWaiting;
+    case kSleeping:                       return kJavaTimedWaiting;
     case kBlocked:                        return kJavaBlocked;
     case kWaiting:                        return kJavaWaiting;
     case kStarting:                       return kJavaNew;
@@ -145,6 +147,12 @@
   }
 }
 
+static void Thread_sleep(JNIEnv* env, jclass, jobject java_lock, jlong ms, jint ns) {
+  ScopedObjectAccess soa(env);
+  Object* lock = soa.Decode<Object*>(java_lock);
+  Monitor::Wait(Thread::Current(), lock, ms, ns, true, kSleeping);
+}
+
 /*
  * Causes the thread to temporarily pause and allow other threads to execute.
  *
@@ -165,6 +173,7 @@
   NATIVE_METHOD(Thread, nativeInterrupt, "()V"),
   NATIVE_METHOD(Thread, nativeSetName, "(Ljava/lang/String;)V"),
   NATIVE_METHOD(Thread, nativeSetPriority, "(I)V"),
+  NATIVE_METHOD(Thread, sleep, "(Ljava/lang/Object;JI)V"),
   NATIVE_METHOD(Thread, yield, "()V"),
 };
 
diff --git a/src/object.cc b/src/object.cc
index c3c4e13..10bf672 100644
--- a/src/object.cc
+++ b/src/object.cc
@@ -156,8 +156,12 @@
   Monitor::NotifyAll(Thread::Current(), this);
 }
 
+void Object::Wait() {
+  Monitor::Wait(Thread::Current(), this, 0, 0, true, kWaiting);
+}
+
 void Object::Wait(int64_t ms, int32_t ns) {
-  Monitor::Wait(Thread::Current(), this, ms, ns, true);
+  Monitor::Wait(Thread::Current(), this, ms, ns, true, kTimedWaiting);
 }
 
 #if VERIFY_OBJECT_ENABLED
diff --git a/src/object.h b/src/object.h
index 60e45c3..07bcde1 100644
--- a/src/object.h
+++ b/src/object.h
@@ -164,10 +164,11 @@
 
   void NotifyAll() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
+  void Wait() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
   void Wait(int64_t timeout) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
-  void Wait(int64_t timeout, int32_t nanos)
-      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+  void Wait(int64_t timeout, int32_t nanos) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
   bool IsClass() const;
 
diff --git a/src/object_utils.h b/src/object_utils.h
index 6924f4e..dd5ff05 100644
--- a/src/object_utils.h
+++ b/src/object_utils.h
@@ -44,7 +44,7 @@
   }
 
   void Wait() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
-    return Monitor::Wait(self_, obj_, 0, 0, false);
+    return Monitor::Wait(self_, obj_, 0, 0, false, kWaiting);
   }
 
   void Notify() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
diff --git a/src/thread.h b/src/thread.h
index ea49960..7bfc2e8 100644
--- a/src/thread.h
+++ b/src/thread.h
@@ -77,23 +77,25 @@
 };
 
 enum ThreadState {
-  kTerminated                     = 0,   // Thread.TERMINATED     JDWP TS_ZOMBIE
-  kRunnable                       = 1,   // Thread.RUNNABLE       JDWP TS_RUNNING
-  kTimedWaiting                   = 2,   // Thread.TIMED_WAITING  JDWP TS_WAIT    - in Object.wait() with a timeout
-  kBlocked                        = 3,   // Thread.BLOCKED        JDWP TS_MONITOR - blocked on a monitor
-  kWaiting                        = 4,   // Thread.WAITING        JDWP TS_WAIT    - in Object.wait()
-  kWaitingForGcToComplete         = 5,   // Thread.WAITING        JDWP TS_WAIT    - blocked waiting for GC
-  kWaitingPerformingGc            = 6,   // Thread.WAITING        JDWP TS_WAIT    - performing GC
-  kWaitingForDebuggerSend         = 7,   // Thread.WAITING        JDWP TS_WAIT    - blocked waiting for events to be sent
-  kWaitingForDebuggerToAttach     = 8,   // Thread.WAITING        JDWP TS_WAIT    - blocked waiting for debugger to attach
-  kWaitingInMainDebuggerLoop      = 9,   // Thread.WAITING        JDWP TS_WAIT    - blocking/reading/processing debugger events
-  kWaitingForDebuggerSuspension   = 10,  // Thread.WAITING        JDWP TS_WAIT    - waiting for debugger suspend all
-  kWaitingForJniOnLoad            = 11,  // Thread.WAITING        JDWP TS_WAIT    - waiting for execution of dlopen and JNI on load code
-  kWaitingForSignalCatcherOutput  = 12,  // Thread.WAITING        JDWP TS_WAIT    - waiting for signal catcher IO to complete
-  kWaitingInMainSignalCatcherLoop = 13,  // Thread.WAITING        JDWP TS_WAIT    - blocking/reading/processing signals
-  kStarting                       = 14,  // Thread.NEW            JDWP TS_WAIT    - native thread started, not yet ready to run managed code
-  kNative                         = 15,  // Thread.RUNNABLE       JDWP TS_RUNNING - running in a JNI native method
-  kSuspended                      = 16,  // Thread.RUNNABLE       JDWP TS_RUNNING - suspended by GC or debugger
+  //                                  Thread.State   JDWP state
+  kTerminated,                     // TERMINATED     TS_ZOMBIE    Thread.run has returned, but Thread* still around
+  kRunnable,                       // RUNNABLE       TS_RUNNING   runnable
+  kTimedWaiting,                   // TIMED_WAITING  TS_WAIT      in Object.wait() with a timeout
+  kSleeping,                       // TIMED_WAITING  TS_SLEEPING  in Thread.sleep()
+  kBlocked,                        // BLOCKED        TS_MONITOR   blocked on a monitor
+  kWaiting,                        // WAITING        TS_WAIT      in Object.wait()
+  kWaitingForGcToComplete,         // WAITING        TS_WAIT      blocked waiting for GC
+  kWaitingPerformingGc,            // WAITING        TS_WAIT      performing GC
+  kWaitingForDebuggerSend,         // WAITING        TS_WAIT      blocked waiting for events to be sent
+  kWaitingForDebuggerToAttach,     // WAITING        TS_WAIT      blocked waiting for debugger to attach
+  kWaitingInMainDebuggerLoop,      // WAITING        TS_WAIT      blocking/reading/processing debugger events
+  kWaitingForDebuggerSuspension,   // WAITING        TS_WAIT      waiting for debugger suspend all
+  kWaitingForJniOnLoad,            // WAITING        TS_WAIT      waiting for execution of dlopen and JNI on load code
+  kWaitingForSignalCatcherOutput,  // WAITING        TS_WAIT      waiting for signal catcher IO to complete
+  kWaitingInMainSignalCatcherLoop, // WAITING        TS_WAIT      blocking/reading/processing signals
+  kStarting,                       // NEW            TS_WAIT      native thread started, not yet ready to run managed code
+  kNative,                         // RUNNABLE       TS_RUNNING   running in a JNI native method
+  kSuspended,                      // RUNNABLE       TS_RUNNING   suspended by GC or debugger
 };
 
 enum ThreadFlag {
diff --git a/test/ThreadStress/ThreadStress.java b/test/ThreadStress/ThreadStress.java
index 5389c20..8d8135d 100644
--- a/test/ThreadStress/ThreadStress.java
+++ b/test/ThreadStress/ThreadStress.java
@@ -34,7 +34,10 @@
         ALLOC(60),
         STACKTRACE(20),
         EXIT(50),
-        WAIT(50);
+
+        SLEEP(25),
+        TIMED_WAIT(10),
+        WAIT(15);
 
         private final int frequency;
         Operation(int frequency) {
@@ -48,7 +51,7 @@
         final int totalOperations = 1000;
         final int operationsPerThread = totalOperations/numberOfThreads;
 
-        // Lock used to notify threads performin Operation.WAIT
+        // Lock used to notify threads performing Operation.WAIT
         final Object lock = new Object();
 
         // Each thread is going to do operationsPerThread
@@ -203,11 +206,26 @@
                         } catch (ErrnoException ex) {
                         }
                     }
+                    case SLEEP: {
+                        try {
+                            Thread.sleep(100);
+                        } catch (InterruptedException ignored) {
+                        }
+                    }
+                    case TIMED_WAIT: {
+                        synchronized (lock) {
+                            try {
+                                lock.wait(100, 0);
+                            } catch (InterruptedException ignored) {
+                            }
+                        }
+                        break;
+                    }
                     case WAIT: {
                         synchronized (lock) {
                             try {
                                 lock.wait();
-                            } catch (InterruptedException e) {
+                            } catch (InterruptedException ignored) {
                             }
                         }
                         break;