1 void ATTR ObjectMonitor::exit(bool not_suspended, TRAPS) { 2 3 Thread * Self = THREAD ; 4 5 if (THREAD != _owner) { 6 7 if (THREAD->is_lock_owned((address) _owner)) { 8 9 // Transmute _owner from a BasicLock pointer to a Thread address. 10 11 // We don't need to hold _mutex for this transition. 12 13 // Non-null to Non-null is safe as long as all readers can 14 15 // tolerate either flavor. 16 17 assert (_recursions == 0, "invariant") ; 18 19 _owner = THREAD ; 20 21 _recursions = 0 ; 22 23 OwnerIsThread = 1 ; 24 25 } else { 26 27 // NOTE: we need to handle unbalanced monitor enter/exit 28 29 // in native code by throwing an exception. 30 31 // TODO: Throw an IllegalMonitorStateException ? 32 33 TEVENT (Exit - Throw IMSX) ; 34 35 assert(false, "Non-balanced monitor enter/exit!"); 36 37 if (false) { 38 39 THROW(vmSymbols::java_lang_IllegalMonitorStateException()); 40 41 } 42 43 return; 44 45 } 46 47 } 48 49 此处是偏向锁逻辑，偏向次数减一后直接返回 50 if (_recursions != 0) { 51 52 _recursions--; // this is simple recursive enter 53 54 TEVENT (Inflated exit - recursive) ; 55 56 return ; 57 58 } 59 60 61 // Invariant: after setting Responsible=null an thread must execute 62 63 // a MEMBAR or other serializing instruction before fetching EntryList|cxq. 64 65 if ((SyncFlags & 4) == 0) { 66 67 _Responsible = NULL ; 68 69 } 70 71 72 #if INCLUDE_TRACE 73 74 // get the owner's thread id for the MonitorEnter event 75 76 // if it is enabled and the thread isn't suspended 77 78 if (not_suspended && Tracing::is_event_enabled(TraceJavaMonitorEnterEvent)) { 79 80 _previous_owner_tid = SharedRuntime::get_java_tid(Self); 81 82 } 83 84 #endif 85 86 87 for (;;) { 88 89 assert (THREAD == _owner, "invariant") ; 90 91 92 93 if (Knob_ExitPolicy == 0) { 94 95 // release semantics: prior loads and stores from within the critical section 96 97 // must not float (reorder) past the following store that drops the lock. 98 99 // On SPARC that requires MEMBAR #loadstore|#storestore. 100 101 // But of course in TSO #loadstore|#storestore is not required. 102 103 // I'd like to write one of the following: 104 105 // A. OrderAccess::release() ; _owner = NULL 106 107 // B. OrderAccess::loadstore(); OrderAccess::storestore(); _owner = NULL; 108 109 // Unfortunately OrderAccess::release() and OrderAccess::loadstore() both 110 111 // store into a _dummy variable. That store is not needed, but can result 112 113 // in massive wasteful coherency traffic on classic SMP systems. 114 115 // Instead, I use release_store(), which is implemented as just a simple 116 117 // ST on x64, x86 and SPARC. 118 119 OrderAccess::release_store_ptr (&_owner, NULL) ; // drop the lock 120 121 OrderAccess::storeload() ; // See if we need to wake a successor 122 123 if ((intptr_t(_EntryList)|intptr_t(_cxq)) == 0 || _succ != NULL) { 124 125 TEVENT (Inflated exit - simple egress) ; 126 127 return ; 128 129 } 130 131 TEVENT (Inflated exit - complex egress) ; 132 133 134 // Normally the exiting thread is responsible for ensuring succession, 135 136 // but if other successors are ready or other entering threads are spinning 137 138 // then this thread can simply store NULL into _owner and exit without 139 140 // waking a successor. The existence of spinners or ready successors 141 142 // guarantees proper succession (liveness). Responsibility passes to the 143 144 // ready or running successors. The exiting thread delegates the duty. 145 146 // More precisely, if a successor already exists this thread is absolved 147 148 // of the responsibility of waking (unparking) one. 149 150 // 151 152 // The _succ variable is critical to reducing futile wakeup frequency. 153 154 // _succ identifies the "heir presumptive" thread that has been made 155 156 // ready (unparked) but that has not yet run. We need only one such 157 158 // successor thread to guarantee progress. 159 160 // See http://www.usenix.org/events/jvm01/full_papers/dice/dice.pdf 161 162 // section 3.3 "Futile Wakeup Throttling" for details. 163 164 // 165 166 // Note that spinners in Enter() also set _succ non-null. 167 168 // In the current implementation spinners opportunistically set 169 170 // _succ so that exiting threads might avoid waking a successor. 171 172 // Another less appealing alternative would be for the exiting thread 173 174 // to drop the lock and then spin briefly to see if a spinner managed 175 176 // to acquire the lock. If so, the exiting thread could exit 177 178 // immediately without waking a successor, otherwise the exiting 179 180 // thread would need to dequeue and wake a successor. 181 182 // (Note that we'd need to make the post-drop spin short, but no 183 184 // shorter than the worst-case round-trip cache-line migration time. 185 186 // The dropped lock needs to become visible to the spinner, and then 187 188 // the acquisition of the lock by the spinner must become visible to 189 190 // the exiting thread). 191 192 // 193 194 195 // It appears that an heir-presumptive (successor) must be made ready. 196 197 // Only the current lock owner can manipulate the EntryList or 198 199 // drain _cxq, so we need to reacquire the lock. If we fail 200 201 // to reacquire the lock the responsibility for ensuring succession 202 203 // falls to the new owner. 204 205 // 206 207 if (Atomic::cmpxchg_ptr (THREAD, &_owner, NULL) != NULL) { 208 209 return ; 210 211 } 212 213 TEVENT (Exit - Reacquired) ; 214 215 } else { 216 217 if ((intptr_t(_EntryList)|intptr_t(_cxq)) == 0 || _succ != NULL) { 218 219 OrderAccess::release_store_ptr (&_owner, NULL) ; // drop the lock 220 221 OrderAccess::storeload() ; 222 223 // Ratify the previously observed values. 224 225 if (_cxq == NULL || _succ != NULL) { 226 227 TEVENT (Inflated exit - simple egress) ; 228 229 return ; 230 231 } 232 233 234 // inopportune interleaving -- the exiting thread (this thread) 235 236 // in the fast-exit path raced an entering thread in the slow-enter 237 238 // path. 239 240 // We have two choices: 241 242 // A. Try to reacquire the lock. 243 244 // If the CAS() fails return immediately, otherwise 245 246 // we either restart/rerun the exit operation, or simply 247 248 // fall-through into the code below which wakes a successor. 249 250 // B. If the elements forming the EntryList|cxq are TSM 251 252 // we could simply unpark() the lead thread and return 253 254 // without having set _succ. 255 256 if (Atomic::cmpxchg_ptr (THREAD, &_owner, NULL) != NULL) { 257 258 TEVENT (Inflated exit - reacquired succeeded) ; 259 260 return ; 261 262 } 263 264 TEVENT (Inflated exit - reacquired failed) ; 265 266 } else { 267 268 TEVENT (Inflated exit - complex egress) ; 269 270 } 271 272 } 273 274 275 guarantee (_owner == THREAD, "invariant") ; 276 277 278 ObjectWaiter * w = NULL ; 279 280 int QMode = Knob_QMode ; 281 282 QMode = 2，并且_cxq非空：取_cxq队列排头位置的ObjectWaiter对象，调用ExitEpilog方法，该方法会唤醒ObjectWaiter对象的线程，此处会立即返回，后面的代码不会执行了 283 if (QMode == 2 && _cxq != NULL) { 284 285 // QMode == 2 : cxq has precedence over EntryList. 286 287 // Try to directly wake a successor from the cxq. 288 289 // If successful, the successor will need to unlink itself from cxq. 290 291 w = _cxq ; 292 293 assert (w != NULL, "invariant") ; 294 295 assert (w->TState == ObjectWaiter::TS_CXQ, "Invariant") ; 296 297 ExitEpilog (Self, w) ; 298 299 return ; 300 301 } 302 303 QMode = 3，并且_cxq非空：把_cxq队列首元素放入_EntryList的尾部； 304 if (QMode == 3 && _cxq != NULL) { 305 306 // Aggressively drain cxq into EntryList at the first opportunity. 307 308 // This policy ensure that recently-run threads live at the head of EntryList. 309 310 // Drain _cxq into EntryList - bulk transfer. 311 312 // First, detach _cxq. 313 314 // The following loop is tantamount to: w = swap (&cxq, NULL) 315 316 w = _cxq ; 317 318 for (;;) { 319 320 assert (w != NULL, "Invariant") ; 321 322 ObjectWaiter * u = (ObjectWaiter *) Atomic::cmpxchg_ptr (NULL, &_cxq, w) ; 323 324 if (u == w) break ; 325 326 w = u ; 327 328 } 329 330 assert (w != NULL , "invariant") ; 331 332 333 ObjectWaiter * q = NULL ; 334 335 ObjectWaiter * p ; 336 337 for (p = w ; p != NULL ; p = p->_next) { 338 339 guarantee (p->TState == ObjectWaiter::TS_CXQ, "Invariant") ; 340 341 p->TState = ObjectWaiter::TS_ENTER ; 342 343 p->_prev = q ; 344 345 q = p ; 346 347 } 348 349 350 // Append the RATs to the EntryList 351 352 // TODO: organize EntryList as a CDLL so we can locate the tail in constant-time. 353 354 ObjectWaiter * Tail ; 355 356 for (Tail = _EntryList ; Tail != NULL && Tail->_next != NULL ; Tail = Tail->_next) ; 357 358 if (Tail == NULL) { 359 360 _EntryList = w ; 361 362 } else { 363 364 Tail->_next = w ; 365 366 w->_prev = Tail ; 367 368 } 369 370 371 // Fall thru into code that tries to wake a successor from EntryList 372 373 } 374 375 Mode = 4，并且_cxq非空：把_cxq队列首元素放入_EntryList的头部； 376 if (QMode == 4 && _cxq != NULL) { 377 378 // Aggressively drain cxq into EntryList at the first opportunity. 379 380 // This policy ensure that recently-run threads live at the head of EntryList. 381 382 383 // Drain _cxq into EntryList - bulk transfer. 384 385 // First, detach _cxq. 386 387 // The following loop is tantamount to: w = swap (&cxq, NULL) 388 389 w = _cxq ; 390 391 for (;;) { 392 393 assert (w != NULL, "Invariant") ; 394 395 ObjectWaiter * u = (ObjectWaiter *) Atomic::cmpxchg_ptr (NULL, &_cxq, w) ; 396 397 if (u == w) break ; 398 399 w = u ; 400 401 } 402 403 assert (w != NULL , "invariant") ; 404 405 406 ObjectWaiter * q = NULL ; 407 408 ObjectWaiter * p ; 409 410 for (p = w ; p != NULL ; p = p->_next) { 411 412 guarantee (p->TState == ObjectWaiter::TS_CXQ, "Invariant") ; 413 414 p->TState = ObjectWaiter::TS_ENTER ; 415 416 p->_prev = q ; 417 418 q = p ; 419 420 } 421 422 423 // Prepend the RATs to the EntryList 424 425 if (_EntryList != NULL) { 426 427 q->_next = _EntryList ; 428 429 _EntryList->_prev = q ; 430 431 } 432 433 _EntryList = w ; 434 435 436 // Fall thru into code that tries to wake a successor from EntryList 437 438 } 439 440 441 w = _EntryList ; 442 443 if (w != NULL) { 444 445 // I'd like to write: guarantee (w->_thread != Self). 446 447 // But in practice an exiting thread may find itself on the EntryList. 448 449 // Lets say thread T1 calls O.wait(). Wait() enqueues T1 on O's waitset and 450 451 // then calls exit(). Exit release the lock by setting O._owner to NULL. 452 453 // Lets say T1 then stalls. T2 acquires O and calls O.notify(). The 454 455 // notify() operation moves T1 from O's waitset to O's EntryList. T2 then 456 457 // release the lock "O". T2 resumes immediately after the ST of null into 458 459 // _owner, above. T2 notices that the EntryList is populated, so it 460 461 // reacquires the lock and then finds itself on the EntryList. 462 463 // Given all that, we have to tolerate the circumstance where "w" is 464 465 // associated with Self. 466 467 assert (w->TState == ObjectWaiter::TS_ENTER, "invariant") ; 468 469 ExitEpilog (Self, w) ; 470 471 return ; 472 473 } 474 475 476 // If we find that both _cxq and EntryList are null then just 477 478 // re-run the exit protocol from the top. 479 480 w = _cxq ; 481 482 if (w == NULL) continue ; 483 484 485 // Drain _cxq into EntryList - bulk transfer. 486 487 // First, detach _cxq. 488 489 // The following loop is tantamount to: w = swap (&cxq, NULL) 490 491 for (;;) { 492 493 assert (w != NULL, "Invariant") ; 494 495 ObjectWaiter * u = (ObjectWaiter *) Atomic::cmpxchg_ptr (NULL, &_cxq, w) ; 496 497 if (u == w) break ; 498 499 w = u ; 500 501 } 502 503 TEVENT (Inflated exit - drain cxq into EntryList) ; 504 505 506 assert (w != NULL , "invariant") ; 507 508 assert (_EntryList == NULL , "invariant") ; 509 510 511 // Convert the LIFO SLL anchored by _cxq into a DLL. 512 513 // The list reorganization step operates in O(LENGTH(w)) time. 514 515 // It's critical that this step operate quickly as 516 517 // "Self" still holds the outer-lock, restricting parallelism 518 519 // and effectively lengthening the critical section. 520 521 // Invariant: s chases t chases u. 522 523 // TODO-FIXME: consider changing EntryList from a DLL to a CDLL so 524 525 // we have faster access to the tail. 526 527 528 if (QMode == 1) { 529 530 // QMode == 1 : drain cxq to EntryList, reversing order 531 532 // We also reverse the order of the list. 533 534 ObjectWaiter * s = NULL ; 535 536 ObjectWaiter * t = w ; 537 538 ObjectWaiter * u = NULL ; 539 540 while (t != NULL) { 541 542 guarantee (t->TState == ObjectWaiter::TS_CXQ, "invariant") ; 543 544 t->TState = ObjectWaiter::TS_ENTER ; 545 546 u = t->_next ; 547 548 t->_prev = u ; 549 550 t->_next = s ; 551 552 s = t; 553 554 t = u ; 555 556 } 557 558 _EntryList = s ; 559 560 assert (s != NULL, "invariant") ; 561 562 } else { 563 564 // QMode == 0 or QMode == 2 565 566 _EntryList = w ; 567 568 ObjectWaiter * q = NULL ; 569 570 ObjectWaiter * p ; 571 572 for (p = w ; p != NULL ; p = p->_next) { 573 574 guarantee (p->TState == ObjectWaiter::TS_CXQ, "Invariant") ; 575 576 p->TState = ObjectWaiter::TS_ENTER ; 577 578 p->_prev = q ; 579 580 q = p ; 581 582 } 583 584 } 585 586 587 // In 1-0 mode we need: ST EntryList; MEMBAR #storestore; ST _owner = NULL 588 589 // The MEMBAR is satisfied by the release_store() operation in ExitEpilog(). 590 591 592 // See if we can abdicate to a spinner instead of waking a thread. 593 594 // A primary goal of the implementation is to reduce the 595 596 // context-switch rate. 597 598 if (_succ != NULL) continue; 599 600 601 w = _EntryList ; 602 603 if (w != NULL) { 604 605 guarantee (w->TState == ObjectWaiter::TS_ENTER, "invariant") ; 606 607 ExitEpilog (Self, w) ; 608 609 return ; 610 611 } 612 613 } 614 615 }
总结释放锁内容：
1. 偏向锁逻辑；
2. 根据QMode的不同，将ObjectWaiter从_cxq或者_EntryList中取出后唤醒；
3. 唤醒的元素会继续执行挂起前的代码，按照我们之前的分析，线程唤醒后，就会通过CAS去竞争锁；
- 根据QMode的不同，将ObjectWaiter从_cxq或者_EntryList中取出后唤醒；