ObjectMonitor::wait(jlong millis, bool interruptible, TRAPS)

  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. 当前线程挂起;

 

上一篇:多线程-3.sleep() yield() join()


下一篇:java线程基本概念