1 // Wait/Notify/NotifyAll 2 3 // 4 5 // Note: a subset of changes to ObjectMonitor::wait() 6 7 // will need to be replicated in complete_exit above 8 9 void ObjectMonitor::wait(jlong millis, bool interruptible, TRAPS) { 10 11 Thread * const Self = THREAD ; 12 13 assert(Self->is_Java_thread(), "Must be Java thread!"); 14 15 JavaThread *jt = (JavaThread *)THREAD; 16 17 18 DeferredInitialize () ; 19 20 21 // Throw IMSX or IEX. 22 23 CHECK_OWNER(); 24 25 26 EventJavaMonitorWait event; 27 28 29 // check for a pending interrupt 30 31 if (interruptible && Thread::is_interrupted(Self, true) && !HAS_PENDING_EXCEPTION) { 32 33 // post monitor waited event. Note that this is past-tense, we are done waiting. 34 35 if (JvmtiExport::should_post_monitor_waited()) { 36 37 // Note: 'false' parameter is passed here because the 38 39 // wait was not timed out due to thread interrupt. 40 41 JvmtiExport::post_monitor_waited(jt, this, false); 42 43 44 // In this short circuit of the monitor wait protocol, the 45 46 // current thread never drops ownership of the monitor and 47 48 // never gets added to the wait queue so the current thread 49 50 // cannot be made the successor. This means that the 51 52 // JVMTI_EVENT_MONITOR_WAITED event handler cannot accidentally 53 54 // consume an unpark() meant for the ParkEvent associated with 55 56 // this ObjectMonitor. 57 58 } 59 60 if (event.should_commit()) { 61 62 post_monitor_wait_event(&event, 0, millis, false); 63 64 } 65 66 TEVENT (Wait - Throw IEX) ; 67 68 THROW(vmSymbols::java_lang_InterruptedException()); 69 70 return ; 71 72 } 73 74 75 TEVENT (Wait) ; 76 77 78 assert (Self->_Stalled == 0, "invariant") ; 79 80 Self->_Stalled = intptr_t(this) ; 81 82 jt->set_current_waiting_monitor(this); 83 84 85 // create a node to be put into the queue 86 87 // Critically, after we reset() the event but prior to park(), we must check 88 89 // for a pending interrupt. 90 将当前线程包装成ObjectWaiter对象，并且状态为TS_WAIT，这里对应的是jstack看到的线程状态WAITING 91 ObjectWaiter node(Self); 92 93 node.TState = ObjectWaiter::TS_WAIT ; 94 95 Self->_ParkEvent->reset() ; 96 97 OrderAccess::fence(); // ST into Event; membar ; LD interrupted-flag 98 99 100 // Enter the waiting queue, which is a circular doubly linked list in this case 101 102 // but it could be a priority queue or any data structure. 103 104 // _WaitSetLock protects the wait queue. Normally the wait queue is accessed only 105 106 // by the the owner of the monitor *except* in the case where park() 107 108 // returns because of a timeout of interrupt. Contention is exceptionally rare 109 110 // so we use a simple spin-lock instead of a heavier-weight blocking lock. 111 112 113 Thread::SpinAcquire (&_WaitSetLock, "WaitSet - add") ; 114 这个ObjectWaiter对象被放入了_WaitSet中，_WaitSet是个环形双向链表(circular doubly linked list) 115 AddWaiter (&node) ; 116 117 Thread::SpinRelease (&_WaitSetLock) ; 118 119 120 if ((SyncFlags & 4) == 0) { 121 122 _Responsible = NULL ; 123 124 } 125 126 intptr_t save = _recursions; // record the old recursion count 127 128 _waiters++; // increment the number of waiters 129 130 _recursions = 0; // set the recursion level to be 1 131 132 exit (true, Self) ; // exit the monitor 133 134 guarantee (_owner != Self, "invariant") ; 135 136 137 // The thread is on the WaitSet list - now park() it. 138 139 // On MP systems it's conceivable that a brief spin before we park 140 141 // could be profitable. 142 143 // 144 145 // TODO-FIXME: change the following logic to a loop of the form 146 147 // while (!timeout && !interrupted && _notified == 0) park() 148 149 150 int ret = OS_OK ; 151 152 int WasNotified = 0 ; 153 154 { // State transition wrappers 155 156 OSThread* osthread = Self->osthread(); 157 158 OSThreadWaitState osts(osthread, true); 159 160 { 161 162 ThreadBlockInVM tbivm(jt); 163 164 // Thread is in thread_blocked state and oop access is unsafe. 165 166 jt->set_suspend_equivalent(); 167 168 169 if (interruptible && (Thread::is_interrupted(THREAD, false) || HAS_PENDING_EXCEPTION)) { 170 171 // Intentionally empty 172 173 } else 174 175 if (node._notified == 0) { 176 177 if (millis <= 0) { 178 当前线程通过park()方法开始挂起(suspend) 179 Self->_ParkEvent->park () ; 180 181 } else { 182 183 ret = Self->_ParkEvent->park (millis) ; 184 185 } 186 187 } 188 189 190 // were we externally suspended while we were waiting? 191 192 if (ExitSuspendEquivalent (jt)) { 193 194 // TODO-FIXME: add -- if succ == Self then succ = null. 195 196 jt->java_suspend_self(); 197 198 } 199 200 201 } // Exit thread safepoint: transition _thread_blocked -> _thread_in_vm 202 203 204 205 // Node may be on the WaitSet, the EntryList (or cxq), or in transition 206 207 // from the WaitSet to the EntryList. 208 209 // See if we need to remove Node from the WaitSet. 210 211 // We use double-checked locking to avoid grabbing _WaitSetLock 212 213 // if the thread is not on the wait queue. 214 215 // 216 217 // Note that we don't need a fence before the fetch of TState. 218 219 // In the worst case we'll fetch a old-stale value of TS_WAIT previously 220 221 // written by the is thread. (perhaps the fetch might even be satisfied 222 223 // by a look-aside into the processor's own store buffer, although given 224 225 // the length of the code path between the prior ST and this load that's 226 227 // highly unlikely). If the following LD fetches a stale TS_WAIT value 228 229 // then we'll acquire the lock and then re-fetch a fresh TState value. 230 231 // That is, we fail toward safety. 232 233 234 if (node.TState == ObjectWaiter::TS_WAIT) { 235 236 Thread::SpinAcquire (&_WaitSetLock, "WaitSet - unlink") ; 237 238 if (node.TState == ObjectWaiter::TS_WAIT) { 239 240 DequeueSpecificWaiter (&node) ; // unlink from WaitSet 241 242 assert(node._notified == 0, "invariant"); 243 244 node.TState = ObjectWaiter::TS_RUN ; 245 246 } 247 248 Thread::SpinRelease (&_WaitSetLock) ; 249 250 } 251 252 253 // The thread is now either on off-list (TS_RUN), 254 255 // on the EntryList (TS_ENTER), or on the cxq (TS_CXQ). 256 257 // The Node's TState variable is stable from the perspective of this thread. 258 259 // No other threads will asynchronously modify TState. 260 261 guarantee (node.TState != ObjectWaiter::TS_WAIT, "invariant") ; 262 263 OrderAccess::loadload() ; 264 265 if (_succ == Self) _succ = NULL ; 266 267 WasNotified = node._notified ; 268 269 270 // Reentry phase -- reacquire the monitor. 271 272 // re-enter contended monitor after object.wait(). 273 274 // retain OBJECT_WAIT state until re-enter successfully completes 275 276 // Thread state is thread_in_vm and oop access is again safe, 277 278 // although the raw address of the object may have changed. 279 280 // (Don't cache naked oops over safepoints, of course). 281 282 283 // post monitor waited event. Note that this is past-tense, we are done waiting. 284 285 if (JvmtiExport::should_post_monitor_waited()) { 286 287 JvmtiExport::post_monitor_waited(jt, this, ret == OS_TIMEOUT); 288 289 290 if (node._notified != 0 && _succ == Self) { 291 292 // In this part of the monitor wait-notify-reenter protocol it 293 294 // is possible (and normal) for another thread to do a fastpath 295 296 // monitor enter-exit while this thread is still trying to get 297 298 // to the reenter portion of the protocol. 299 300 // 301 302 // The ObjectMonitor was notified and the current thread is 303 304 // the successor which also means that an unpark() has already 305 306 // been done. The JVMTI_EVENT_MONITOR_WAITED event handler can 307 308 // consume the unpark() that was done when the successor was 309 310 // set because the same ParkEvent is shared between Java 311 312 // monitors and JVM/TI RawMonitors (for now). 313 314 // 315 316 // We redo the unpark() to ensure forward progress, i.e., we 317 318 // don't want all pending threads hanging (parked) with none 319 320 // entering the unlocked monitor. 321 322 node._event->unpark(); 323 324 } 325 326 } 327 328 329 if (event.should_commit()) { 330 331 post_monitor_wait_event(&event, node._notifier_tid, millis, ret == OS_TIMEOUT); 332 333 } 334 335 336 OrderAccess::fence() ; 337 338 339 assert (Self->_Stalled != 0, "invariant") ; 340 341 Self->_Stalled = 0 ; 342 343 344 assert (_owner != Self, "invariant") ; 345 346 ObjectWaiter::TStates v = node.TState ; 347 348 if (v == ObjectWaiter::TS_RUN) { 349 350 enter (Self) ; 351 352 } else { 353 354 guarantee (v == ObjectWaiter::TS_ENTER || v == ObjectWaiter::TS_CXQ, "invariant") ; 355 356 ReenterI (Self, &node) ; 357 358 node.wait_reenter_end(this); 359 360 } 361 362 363 // Self has reacquired the lock. 364 365 // Lifecycle - the node representing Self must not appear on any queues. 366 367 // Node is about to go out-of-scope, but even if it were immortal we wouldn't 368 369 // want residual elements associated with this thread left on any lists. 370 371 guarantee (node.TState == ObjectWaiter::TS_RUN, "invariant") ; 372 373 assert (_owner == Self, "invariant") ; 374 375 assert (_succ != Self , "invariant") ; 376 377 } // OSThreadWaitState() 378 379 380 jt->set_current_waiting_monitor(NULL); 381 382 383 guarantee (_recursions == 0, "invariant") ; 384 385 _recursions = save; // restore the old recursion count 386 387 _waiters--; // decrement the number of waiters 388 389 390 // Verify a few postconditions 391 392 assert (_owner == Self , "invariant") ; 393 394 assert (_succ != Self , "invariant") ; 395 396 assert (((oop)(object()))->mark() == markOopDesc::encode(this), "invariant") ; 397 398 399 if (SyncFlags & 32) { 400 401 OrderAccess::fence() ; 402 403 } 404 405 406 // check if the notification happened 407 408 if (!WasNotified) { 409 410 // no, it could be timeout or Thread.interrupt() or both 411 412 // check for interrupt event, otherwise it is timeout 413 414 if (interruptible && Thread::is_interrupted(Self, true) && !HAS_PENDING_EXCEPTION) { 415 416 TEVENT (Wait - throw IEX from epilog) ; 417 418 THROW(vmSymbols::java_lang_InterruptedException()); 419 420 } 421 422 } 423 424 425 // NOTE: Spurious wake up will be consider as timeout. 426 427 // Monitor notify has precedence over thread interrupt. 428 429 }
ObjectMonitor::wait(jlong millis, bool interruptible, TRAPS)
总结：wait（）方法的内容
1. 把当前线程包装成ObjectWaiter对象，状态为TS_WAIT;
2. ObjectWaiter对象被放入_WaitSet中；
3. 当前线程挂起；