2562 // TODO-FIXME: reconcile Solaris' os::sleep with the bsd variation.

  2563 // Solaris uses poll(), bsd uses park().

  2564 // Poll() is likely a better choice, assuming that Thread.interrupt()

  2565 // generates a SIGUSRx signal. Note that SIGUSR1 can interfere with

  2566 // SIGSEGV, see 4355769.

  2567 

  2568 int os::sleep(Thread* thread, jlong millis, bool interruptible) {

  2569   assert(thread == Thread::current(),  "thread consistency check");

  2570 

  2571   ParkEvent * const slp = thread->_SleepEvent ;

  2572   slp->reset() ;

  2573   OrderAccess::fence() ;

  2574 

  2575   if (interruptible) {

  2576     jlong prevtime = javaTimeNanos();

  2577 

  2578     for (;;) {

  2579       if (os::is_interrupted(thread, true)) {

  2580         return OS_INTRPT;

  2581       }

  2582 

  2583       jlong newtime = javaTimeNanos();

  2584 

  2585       if (newtime - prevtime < 0) {

  2586         // time moving backwards, should only happen if no monotonic clock

  2587         // not a guarantee() because JVM should not abort on kernel/glibc bugs

  2588         assert(!Bsd::supports_monotonic_clock(), "time moving backwards");

  2589       } else {

  2590         millis -= (newtime - prevtime) / NANOSECS_PER_MILLISEC;

  2591       }

  2592 

  2593       if(millis <= 0) {

  2594         return OS_OK;

  2595       }

  2596 

  2597       prevtime = newtime;

  2598 

  2599       {

  2600         assert(thread->is_Java_thread(), "sanity check");

  2601         JavaThread *jt = (JavaThread *) thread;

  2602         ThreadBlockInVM tbivm(jt);

  2603         OSThreadWaitState osts(jt->osthread(), false /* not Object.wait() */);

  2604 

  2605         jt->set_suspend_equivalent();

  2606         // cleared by handle_special_suspend_equivalent_condition() or

  2607         // java_suspend_self() via check_and_wait_while_suspended()

  2608 

  2609         slp->park(millis);

  2610 

  2611         // were we externally suspended while we were waiting?

  2612         jt->check_and_wait_while_suspended();

  2613       }

  2614     }

  2615   } else {

  2616     OSThreadWaitState osts(thread->osthread(), false /* not Object.wait() */);

  2617     jlong prevtime = javaTimeNanos();

  2618 

  2619     for (;;) {

  2620       // It'd be nice to avoid the back-to-back javaTimeNanos() calls on

  2621       // the 1st iteration ...

  2622       jlong newtime = javaTimeNanos();

  2623 

  2624       if (newtime - prevtime < 0) {

  2625         // time moving backwards, should only happen if no monotonic clock

  2626         // not a guarantee() because JVM should not abort on kernel/glibc bugs

  2627         assert(!Bsd::supports_monotonic_clock(), "time moving backwards");

  2628       } else {

  2629         millis -= (newtime - prevtime) / NANOSECS_PER_MILLISEC;

  2630       }

  2631 

  2632       if(millis <= 0) break ;

  2633 

  2634       prevtime = newtime;

  2635       slp->park(millis);

  2636     }

  2637     return OS_OK ;

  2638   }

  2639 }

  2640 

  3034 }

  3035 

  3036 ////////////////////////////////////////////////////////////////////////////////

  3037 // interrupt support

  3038 

  3039 void os::interrupt(Thread* thread) {

  3040   assert(Thread::current() == thread || Threads_lock->owned_by_self(),

  3041     "possibility of dangling Thread pointer");

  3042 

  3043   OSThread* osthread = thread->osthread();

  3044 

  3045   if (!osthread->interrupted()) {

  3046     osthread->set_interrupted(true);

  3047     // More than one thread can get here with the same value of osthread,

  3048     // resulting in multiple notifications.  We do, however, want the store

  3049     // to interrupted() to be visible to other threads before we execute unpark().

  3050     OrderAccess::fence();

  3051     ParkEvent * const slp = thread->_SleepEvent ;

  3052     if (slp != NULL) slp->unpark() ;

  3053   }

  3054 

  3055   // For JSR166. Unpark even if interrupt status already was set

  3056   if (thread->is_Java_thread())

  3057     ((JavaThread*)thread)->parker()->unpark();

  3058 

  3059   ParkEvent * ev = thread->_ParkEvent ;

  3060   if (ev != NULL) ev->unpark() ;

  3061 

  3062 }

  3063 

  3064 bool os::is_interrupted(Thread* thread, bool clear_interrupted) {

  3065   assert(Thread::current() == thread || Threads_lock->owned_by_self(),

  3066     "possibility of dangling Thread pointer");

  3067 

  3068   OSThread* osthread = thread->osthread();

  3069 

  3070   bool interrupted = osthread->interrupted();

  3071 

  3072   if (interrupted && clear_interrupted) {

  3073     osthread->set_interrupted(false);

  3074     // consider thread->_SleepEvent->reset() ... optional optimization

  3075   }

  3076 

  3077   return interrupted;