Esempio n. 1
0
  // Private since we can't add a vtable slot in 4.1.x.
  private void exitNoChecks(int status) {
    if (runShutdownHooks()) exitInternal(status);

    // Someone else already called runShutdownHooks().
    // Make sure we are not/no longer in the shutdownHooks set.
    // And wait till the thread that is calling runShutdownHooks() finishes.
    synchronized (libpath) {
      if (shutdownHooks != null) {
        shutdownHooks.remove(Thread.currentThread());
        // Interrupt the exit sequence thread, in case it was waiting
        // inside a join on our thread.
        exitSequence.interrupt();
        // Shutdown hooks are still running, so we clear status to
        // make sure we don't halt.
        status = 0;
      }
    }

    // If exit() is called again after the shutdown hooks have run, but
    // while finalization for exit is going on and the status is non-zero
    // we halt immediately.
    if (status != 0) exitInternal(status);

    while (true)
      try {
        exitSequence.join();
      } catch (InterruptedException e) {
        // Ignore, we've suspended indefinitely to let all shutdown
        // hooks complete, and to let any non-zero exits through, because
        // this is a duplicate call to exit(0).
      }
  }
Esempio n. 2
0
 /**
  * Waits for the runtime thread to stop. This interrupts the thread currently running the
  * runnable and then waits for it to exit.
  */
 public void stop() {
   Thread threadToStop;
   synchronized (this) {
     threadToStop = thread;
     thread = null;
   }
   if (threadToStop == null) {
     throw new IllegalStateException("not running");
   }
   threadToStop.interrupt();
   while (true) {
     try {
       threadToStop.join();
       return;
     } catch (InterruptedException ignored) {
     }
   }
 }
Esempio n. 3
0
  /**
   * Parks the current thread for a particular number of nanoseconds, or indefinitely. If not
   * indefinitely, this method unparks the thread after the given number of nanoseconds if no other
   * thread unparks it first. If the thread has been "preemptively unparked," this method cancels
   * that unparking and returns immediately. This method may also return spuriously (that is,
   * without the thread being told to unpark and without the indicated amount of time elapsing).
   *
   * <p>See {@link java.util.concurrent.locks.LockSupport} for more in-depth information of the
   * behavior of this method.
   *
   * <p>This method must only be called when <code>this</code> is the current thread.
   *
   * @param nanos number of nanoseconds to park for or <code>0</code> to park indefinitely
   * @throws IllegalArgumentException thrown if <code>nanos &lt; 0</code>
   * @hide for Unsafe
   */
  public void parkFor(long nanos) {
    VMThread vmt = vmThread;

    if (vmt == null) {
      // Running threads should always have an associated vmThread.
      throw new AssertionError();
    }

    synchronized (vmt) {
      switch (parkState) {
        case ParkState.PREEMPTIVELY_UNPARKED:
          {
            parkState = ParkState.UNPARKED;
            break;
          }
        case ParkState.UNPARKED:
          {
            long millis = nanos / NANOS_PER_MILLI;
            nanos %= NANOS_PER_MILLI;

            parkState = ParkState.PARKED;
            try {
              vmt.wait(millis, (int) nanos);
            } catch (InterruptedException ex) {
              interrupt();
            } finally {
              /*
               * Note: If parkState manages to become
               * PREEMPTIVELY_UNPARKED before hitting this
               * code, it should left in that state.
               */
              if (parkState == ParkState.PARKED) {
                parkState = ParkState.UNPARKED;
              }
            }
            break;
          }
        default /*parked*/:
          {
            throw new AssertionError("shouldn't happen: attempt to repark");
          }
      }
    }
  }
Esempio n. 4
0
 public void finish() {
   stop = true;
   thread.interrupt();
 }
Esempio n. 5
0
 public synchronized void interrupt() {
   if (thread == null) {
     throw new IllegalStateException("not running");
   }
   thread.interrupt();
 }