[java] view
plaincopy

1. public native void unpark(Thread jthread);
2. public native void park(boolean isAbsolute, long time);

[cpp] view
plaincopy

1. class Parker : public os::PlatformParker {
2. private:
3. volatile int _counter ;
4. ...
5. public:
6. void park(bool isAbsolute, jlong time);
7. void unpark();
8. ...
9. }
10. class PlatformParker : public CHeapObj<mtInternal> {
11. protected:
12. pthread_mutex_t _mutex [1] ;
13. pthread_cond_t  _cond  [1] ;
14. ...
15. }

[cpp] view
plaincopy

1. void Parker::park(bool isAbsolute, jlong time) {
2. // Ideally we'd do something useful while spinning, such
3. // as calling unpackTime().
4. // Optional fast-path check:
5. // Return immediately if a permit is available.
6. // We depend on Atomic::xchg() having full barrier semantics
7. // since we are doing a lock-free update to _counter.
8. if (Atomic::xchg(0, &_counter) > 0) return;

[cpp] view
plaincopy

1. ThreadBlockInVM tbivm(jt);
2. if (_counter > 0)  { // no wait needed
3. _counter = 0;
4. status = pthread_mutex_unlock(_mutex);

[cpp] view
plaincopy

1. if (time == 0) {
2. status = pthread_cond_wait (_cond, _mutex) ;
3. }
4. _counter = 0 ;
5. status = pthread_mutex_unlock(_mutex) ;
6. assert_status(status == 0, status, "invariant") ;
7. OrderAccess::fence();

[cpp] view
plaincopy

1. void Parker::unpark() {
2. int s, status ;
3. status = pthread_mutex_lock(_mutex);
4. assert (status == 0, "invariant") ;
5. s = _counter;
6. _counter = 1;
7. if (s < 1) {
8. if (WorkAroundNPTLTimedWaitHang) {
9. status = pthread_cond_signal (_cond) ;
10. assert (status == 0, "invariant") ;
11. status = pthread_mutex_unlock(_mutex);
12. assert (status == 0, "invariant") ;
13. } else {
14. status = pthread_mutex_unlock(_mutex);
15. assert (status == 0, "invariant") ;
16. status = pthread_cond_signal (_cond) ;
17. assert (status == 0, "invariant") ;
18. }
19. } else {
20. pthread_mutex_unlock(_mutex);
21. assert (status == 0, "invariant") ;
22. }
23. }

[cpp] view
plaincopy

1. if (time == 0) {
2. status = pthread_cond_wait (_cond, _mutex) ;
3. }

1. // We use placement-new to force ParkEvent instances to be
2. // aligned on 256-byte address boundaries.  This ensures that the least
3. // significant byte of a ParkEvent address is always 0.
4. void * operator new (size_t sz) ;

1. volatile int Parker::ListLock = 0 ;
2. Parker * volatile Parker::FreeList = NULL ;
3. Parker * Parker::Allocate (JavaThread * t) {
4. guarantee (t != NULL, "invariant") ;
5. Parker * p ;
6. // Start by trying to recycle an existing but unassociated
7. // Parker from the global free list.
8. for (;;) {
9. p = FreeList ;
10. if (p  == NULL) break ;
11. // 1: Detach
12. // Tantamount to p = Swap (&FreeList, NULL)
13. if (Atomic::cmpxchg_ptr (NULL, &FreeList, p) != p) {
14. continue ;
15. }
16. // We've detached the list.  The list in-hand is now
17. // local to this thread.   This thread can operate on the
18. // list without risk of interference from other threads.
19. // 2: Extract -- pop the 1st element from the list.
20. Parker * List = p->FreeNext ;
21. if (List == NULL) break ;
22. for (;;) {
23. // 3: Try to reattach the residual list
24. guarantee (List != NULL, "invariant") ;
25. Parker * Arv =  (Parker *) Atomic::cmpxchg_ptr (List, &FreeList, NULL) ;
26. if (Arv == NULL) break ;
27. // New nodes arrived.  Try to detach the recent arrivals.
28. if (Atomic::cmpxchg_ptr (NULL, &FreeList, Arv) != Arv) {
29. continue ;
30. }
31. guarantee (Arv != NULL, "invariant") ;
32. // 4: Merge Arv into List
33. Parker * Tail = List ;
34. while (Tail->FreeNext != NULL) Tail = Tail->FreeNext ;
35. Tail->FreeNext = Arv ;
36. }
37. break ;
38. }
39. if (p != NULL) {
40. guarantee (p->AssociatedWith == NULL, "invariant") ;
41. } else {
42. // Do this the hard way -- materialize a new Parker..
43. // In rare cases an allocating thread might detach
44. // a long list -- installing null into FreeList --and
45. // then stall.  Another thread calling Allocate() would see
46. // FreeList == null and then invoke the ctor.  In this case we
47. // end up with more Parkers in circulation than we need, but
48. // the race is rare and the outcome is benign.
49. // Ideally, the # of extant Parkers is equal to the
50. // maximum # of threads that existed at any one time.
51. // Because of the race mentioned above, segments of the
52. // freelist can be transiently inaccessible.  At worst
53. // we may end up with the # of Parkers in circulation
54. // slightly above the ideal.
55. p = new Parker() ;
56. }
57. p->AssociatedWith = t ;          // Associate p with t
58. p->FreeNext       = NULL ;
59. return p ;
60. }
61. void Parker::Release (Parker * p) {
62. if (p == NULL) return ;
63. guarantee (p->AssociatedWith != NULL, "invariant") ;
64. guarantee (p->FreeNext == NULL      , "invariant") ;
65. p->AssociatedWith = NULL ;
66. for (;;) {
67. // Push p onto FreeList
68. Parker * List = FreeList ;
69. p->FreeNext = List ;
70. if (Atomic::cmpxchg_ptr (p, &FreeList, List) == List) break ;
71. }
72. }

版权声明：本文博主原创文章，博客，未经同意不得转载。