示例#1
1
  /**
   * Disconnect a mavlink connection. If the operation is successful, it will be reported through
   * the MavLinkConnectionListener interface.
   */
  public void disconnect() {
    if (mConnectionStatus.get() == MAVLINK_DISCONNECTED
        || (mConnectThread == null && mTaskThread == null)) {
      return;
    }

    try {
      final long disconnectTime = System.currentTimeMillis();

      mConnectionStatus.set(MAVLINK_DISCONNECTED);
      mConnectionTime.set(-1);

      if (mConnectThread != null && mConnectThread.isAlive() && !mConnectThread.isInterrupted()) {
        mConnectThread.interrupt();
      }

      if (mTaskThread != null && mTaskThread.isAlive() && !mTaskThread.isInterrupted()) {
        mTaskThread.interrupt();
      }

      closeConnection();
      reportDisconnect(disconnectTime);
    } catch (IOException e) {
      mLogger.logErr(TAG, e);
      reportComError(e.getMessage());
    }
  }
  /**
   * @param args
   * @throws InterruptedException
   */
  public static void main(String[] args) throws InterruptedException {

    Thread t1 =
        new Thread() {
          @Override
          public void run() {
            long i = 0l;
            try {

              while (this.isInterrupted() == false) {
                System.out.println(Thread.currentThread().getName() + " sleep 10 ");
                TimeUnit.SECONDS.sleep(10);
              }
            } catch (InterruptedException e) // 会抛出InterruptException因为Sleep会阻塞
            {
              e.printStackTrace();
              System.out.println(Thread.currentThread().getName() + ":" + e.getMessage());
            }
          }
        };

    Thread t2 =
        new Thread() {
          @Override
          public void run() {
            long i = 0l;
            while (this.isInterrupted() == false) {
              try {
                Thread.currentThread().sleep(1);
                i++;
                while (true) {
                  i++;
                }
              } catch (InterruptedException e) {
                // TODO 自动生成的 catch 块
                e.printStackTrace();
              }
            }
          }
        };

    t1.start();
    t2.start();

    System.out.println(
        t1.getName() + " before interupt:" + t1.isInterrupted() + "   is alive=" + t1.isAlive());
    System.out.println(
        t2.getName() + " before interupt:" + t2.isInterrupted() + "   is alive=" + t2.isAlive());
    TimeUnit.SECONDS.sleep(1);
    t1.interrupt();
    t2.interrupt();
    TimeUnit.SECONDS.sleep(1);
    System.out.println(
        t1.getName() + " after interupt:" + t1.isInterrupted() + "   is alive=" + t1.isAlive());
    System.out.println(
        t2.getName() + " after interupt:" + t2.isInterrupted() + "   is alive=" + t2.isAlive());
  }
示例#3
1
  /**
   * Parse an XML document from a location identified by an URI reference. If the URI contains a
   * fragment identifier (see section 4.1 in ), the behavior is not defined by this specification.
   */
  public Document parseURI(String uri) throws LSException {

    // If DOMParser insstance is already busy parsing another document when this
    // method is called, then raise INVALID_STATE_ERR according to DOM L3 LS spec
    if (fBusy) {
      String msg =
          DOMMessageFormatter.formatMessage(
              DOMMessageFormatter.DOM_DOMAIN, "INVALID_STATE_ERR", null);
      throw new DOMException(DOMException.INVALID_STATE_ERR, msg);
    }

    XMLInputSource source = new XMLInputSource(null, uri, null, false);
    try {
      currentThread = Thread.currentThread();
      fBusy = true;
      parse(source);
      fBusy = false;
      if (abortNow && currentThread.isInterrupted()) {
        // reset interrupt state
        abortNow = false;
        Thread.interrupted();
      }
    } catch (Exception e) {
      fBusy = false;
      if (abortNow && currentThread.isInterrupted()) {
        Thread.interrupted();
      }
      if (abortNow) {
        abortNow = false;
        restoreHandlers();
        return null;
      }
      // Consume this exception if the user
      // issued an interrupt or an abort.
      if (e != Abort.INSTANCE) {
        if (!(e instanceof XMLParseException) && fErrorHandler != null) {
          DOMErrorImpl error = new DOMErrorImpl();
          error.fException = e;
          error.fMessage = e.getMessage();
          error.fSeverity = DOMError.SEVERITY_FATAL_ERROR;
          fErrorHandler.getErrorHandler().handleError(error);
        }
        if (DEBUG) {
          e.printStackTrace();
        }
        throw (LSException) DOMUtil.createLSException(LSException.PARSE_ERR, e).fillInStackTrace();
      }
    }
    Document doc = getDocument();
    dropDocumentReferences();
    return doc;
  }
示例#4
1
  /** Parse an XML document from a resource identified by an <code>LSInput</code>. */
  public Document parse(LSInput is) throws LSException {

    // need to wrap the LSInput with an XMLInputSource
    XMLInputSource xmlInputSource = dom2xmlInputSource(is);
    if (fBusy) {
      String msg =
          DOMMessageFormatter.formatMessage(
              DOMMessageFormatter.DOM_DOMAIN, "INVALID_STATE_ERR", null);
      throw new DOMException(DOMException.INVALID_STATE_ERR, msg);
    }

    try {
      currentThread = Thread.currentThread();
      fBusy = true;
      parse(xmlInputSource);
      fBusy = false;
      if (abortNow && currentThread.isInterrupted()) {
        // reset interrupt state
        abortNow = false;
        Thread.interrupted();
      }
    } catch (Exception e) {
      fBusy = false;
      if (abortNow && currentThread.isInterrupted()) {
        Thread.interrupted();
      }
      if (abortNow) {
        abortNow = false;
        restoreHandlers();
        return null;
      }
      // Consume this exception if the user
      // issued an interrupt or an abort.
      if (e != Abort.INSTANCE) {
        if (!(e instanceof XMLParseException) && fErrorHandler != null) {
          DOMErrorImpl error = new DOMErrorImpl();
          error.fException = e;
          error.fMessage = e.getMessage();
          error.fSeverity = DOMError.SEVERITY_FATAL_ERROR;
          fErrorHandler.getErrorHandler().handleError(error);
        }
        if (DEBUG) {
          e.printStackTrace();
        }
        throw (LSException) DOMUtil.createLSException(LSException.PARSE_ERR, e).fillInStackTrace();
      }
    }
    Document doc = getDocument();
    dropDocumentReferences();
    return doc;
  }
示例#5
1
  public SearcherResult findRuleMatchesOnIndex(PatternRule rule, Language language)
      throws IOException, UnsupportedPatternRuleException {
    // it seems wasteful to re-open the index every time, but I had strange problems (OOM, Array out
    // of bounds, ...)
    // when not doing so...
    open();
    try {
      final PatternRuleQueryBuilder patternRuleQueryBuilder = new PatternRuleQueryBuilder(language);
      final Query query = patternRuleQueryBuilder.buildRelaxedQuery(rule);
      if (query == null) {
        throw new NullPointerException("Cannot search on null query for rule: " + rule.getId());
      }

      final SearchRunnable runnable = new SearchRunnable(indexSearcher, query, language, rule);
      final Thread searchThread = new Thread(runnable);
      searchThread.start();
      try {
        // using a TimeLimitingCollector is not enough, as it doesn't cover all time required to
        // search for a complicated regex, so interrupt the whole thread instead:
        if (limitSearch) { // FIXME: I don't know a simpler way to achieve this
          searchThread.join(maxSearchTimeMillis);
        } else {
          searchThread.join(Integer.MAX_VALUE);
        }
        searchThread.interrupt();
      } catch (InterruptedException e) {
        throw new RuntimeException("Search thread got interrupted for query " + query, e);
      }
      if (searchThread.isInterrupted()) {
        throw new SearchTimeoutException(
            "Search timeout of " + maxSearchTimeMillis + "ms reached for query " + query);
      }
      final Exception exception = runnable.getException();
      if (exception != null) {
        if (exception instanceof SearchTimeoutException) {
          throw (SearchTimeoutException) exception;
        }
        throw new RuntimeException(
            "Exception during search for query " + query + " on rule " + rule.getId(), exception);
      }

      final List<MatchingSentence> matchingSentences = runnable.getMatchingSentences();
      final int sentencesChecked = getSentenceCheckCount(query, indexSearcher);
      final SearcherResult searcherResult =
          new SearcherResult(matchingSentences, sentencesChecked, query);
      searcherResult.setHasTooManyLuceneMatches(runnable.hasTooManyLuceneMatches());
      searcherResult.setLuceneMatchCount(runnable.getLuceneMatchCount());
      if (runnable.hasTooManyLuceneMatches()) {
        // more potential matches than we can check in an acceptable time :-(
        searcherResult.setDocCount(maxHits);
      } else {
        searcherResult.setDocCount(getDocCount(indexSearcher));
      }
      // TODO: the search itself could also timeout, don't just ignore that:
      // searcherResult.setResultIsTimeLimited(limitedTopDocs.resultIsTimeLimited);
      return searcherResult;
    } finally {
      close();
    }
  }
  @Test
  public void testThreadDetails() {
    final AtomicReference<Thread> threadRef = new AtomicReference<Thread>();
    SingleThreadEventExecutor executor =
        new SingleThreadEventExecutor(null, Executors.newCachedThreadPool(), false) {
          @Override
          protected void run() {
            threadRef.set(Thread.currentThread());
            while (!confirmShutdown()) {
              Runnable task = takeTask();
              if (task != null) {
                task.run();
              }
            }
          }
        };
    ThreadProperties threadProperties = executor.threadProperties();
    Assert.assertSame(threadProperties, executor.threadProperties());

    Thread thread = threadRef.get();
    Assert.assertEquals(thread.getId(), threadProperties.id());
    Assert.assertEquals(thread.getName(), threadProperties.name());
    Assert.assertEquals(thread.getPriority(), threadProperties.priority());
    Assert.assertEquals(thread.getState(), threadProperties.state());
    Assert.assertEquals(thread.isAlive(), threadProperties.isAlive());
    Assert.assertEquals(thread.isDaemon(), threadProperties.isDaemon());
    Assert.assertEquals(thread.isInterrupted(), threadProperties.isInterrupted());
    Assert.assertTrue(threadProperties.stackTrace().length > 0);
    executor.shutdownGracefully();
  }
 @Override
 public void stop() {
   while (!sqlt.isInterrupted()) {
     sqlt.interrupt();
   }
   System.out.println("MySQL monitor stopped!");
 }
示例#8
0
  /**
   * Spins/yields/blocks until node s is matched or caller gives up.
   *
   * @param s the waiting node
   * @param pred the predecessor of s, or s itself if it has no predecessor, or null if unknown (the
   *     null case does not occur in any current calls but may in possible future extensions)
   * @param e the comparison value for checking match
   * @param timed if true, wait only until timeout elapses
   * @param nanos timeout in nanosecs, used only if timed is true
   * @return matched item, or e if unmatched on interrupt or timeout
   */
  private E awaitMatch(Node s, Node pred, E e, boolean timed, long nanos) {
    final long deadline = timed ? System.nanoTime() + nanos : 0L;
    Thread w = Thread.currentThread();
    int spins = -1; // initialized after first item and cancel checks
    ThreadLocalRandom randomYields = null; // bound if needed

    for (; ; ) {
      Object item = s.item;
      if (item != e) { // matched
        // assert item != s;
        s.forgetContents(); // avoid garbage
        return LinkedTransferQueue.<E>cast(item);
      }
      if ((w.isInterrupted() || (timed && nanos <= 0)) && s.casItem(e, FORGOTTEN)) { // cancel
        unsplice(pred, s);
        return e;
      }

      if (spins < 0) { // establish spins at/near front
        if ((spins = spinsFor(pred, s.isData)) > 0) randomYields = ThreadLocalRandom.current();
      } else if (spins > 0) { // spin
        --spins;
        if (randomYields.nextInt(CHAINED_SPINS) == 0) Thread.yield(); // occasionally yield
      } else if (s.waiter == null) {
        s.waiter = w; // request unpark then recheck
      } else if (timed) {
        nanos = deadline - System.nanoTime();
        if (nanos > 0L) LockSupport.parkNanos(this, nanos);
      } else {
        LockSupport.park(this);
      }
    }
  }
  public void stopServer() throws Exception {
    if (!thread.isInterrupted()) thread.interrupt();

    while (thread.isAlive()) {
      Thread.sleep(250);
    }
  }
示例#10
0
 private void parse(
     final DataInputStream dis,
     final GenometryModel gmodel,
     final AnnotatedSeqGroup seq_group,
     final String default_type)
     throws IOException {
   String type = default_type;
   String bedType = null;
   boolean use_item_rgb = false;
   final Thread thread = Thread.currentThread();
   final BufferedReader reader = new BufferedReader(new InputStreamReader(dis));
   String line;
   while ((line = reader.readLine()) != null && !thread.isInterrupted()) {
     if (!line.startsWith("#")) {
       if (line.length() == 0) {
         continue;
       }
       if (line.startsWith("track")) {
         this.track_line_parser.parseTrackLine(line);
         TrackLineParser.createTrackStyle(
             this.track_line_parser.getCurrentTrackHash(), default_type, "bed");
         type = this.track_line_parser.getCurrentTrackHash().get("name");
         final String item_rgb_string =
             this.track_line_parser.getCurrentTrackHash().get("itemrgb");
         use_item_rgb = "on".equalsIgnoreCase(item_rgb_string);
         bedType = this.track_line_parser.getCurrentTrackHash().get("type");
       } else {
         if (line.startsWith("browser")) {
           continue;
         }
         this.parseLine(line, seq_group, gmodel, type, use_item_rgb, bedType);
       }
     }
   }
 }
 private void runLogging() {
   final Thread currentThread = Thread.currentThread();
   final ConsoleRowFormatter consoleRowFormatter = new ConsoleRowFormatter();
   anythingLogged = false;
   try {
     while (!currentThread.isInterrupted()) {
       ConsoleRow row = outputQueue.take();
       // subtract length of contained test string
       modifyCharacterCount(-row.getPayload().length());
       try {
         // TODO add an explicit flush mechanism to ensure rows are on disk after a
         // given time?
         writer.append(consoleRowFormatter.toCombinedLogFileFormat(row));
         anythingLogged = true;
       } catch (IOException e) {
         log.error(e);
         break;
       }
     }
   } catch (InterruptedException e) {
     log.debug("Background log writer interrupted");
   }
   try {
     writer.close();
     // TODO bad encapsulation; improve when reworking this class
     if (!anythingLogged) {
       logFile.delete();
     }
   } catch (IOException e) {
     log.error(e);
   }
 }
 @Override
 public synchronized void run() {
   try {
     while (!myThread.isInterrupted() && !exhausted) {
       synchronized (this) {
         while (!outstandingFillRequest) {
           wait();
         }
       }
       fill();
       outstandingFillRequest = false;
     }
   } catch (InterruptedException e) {
     // TODO: handle exception
   } catch (ThreadDeath e) {
     throw e;
   } catch (Throwable e) {
     exception = e;
   } finally {
     exhausted = true;
     synchronized (lockObject) {
       lockObject.notifyAll();
     }
     try {
       in.close();
     } catch (IOException e) {
       if (exception == null) {
         exception = e;
       }
     }
     in = null;
   }
 }
示例#13
0
  /** @param args */
  public static void main(String[] args) throws Exception {
    final Thread thread = Thread.currentThread();
    final CloneClient cloneClient = Patterns.newCloneClient("localhost", "localhost", "/client/");

    Random rand = new Random(System.nanoTime());
    while (!thread.isInterrupted()) {
      //  Set random value, check it was stored
      String key = String.format("%s%d", "/client/", rand.nextInt(10000));
      String value = String.format("%d", rand.nextInt(1000000));
      log.info("Publishing update: {}={}", key, value);
      cloneClient.set(key, value, rand.nextInt(30));
      Thread.sleep(1000);
    }

    Runtime.getRuntime()
        .addShutdownHook(
            new Thread() {
              @Override
              public void run() {
                log.info("Stopping CloneClient...");
                thread.interrupt();
                try {
                  thread.join();
                } catch (InterruptedException ignored) {
                }
                log.info("CloneClient stopped");
              }
            });
  }
示例#14
0
  /** Stop the update thread. Also flush the remaining updates since we're stopping anyway */
  public void stop() {
    running = false;

    if (thread != null && !thread.isInterrupted()) {
      thread.interrupt();
    }
  }
    @Override
    public void run() {
      Thread currentThread = Thread.currentThread();

      while (!currentThread.isInterrupted()) {
        _selectorIntraband.selector.wakeup();
      }
    }
 @Override
 public void stop() {
   channel.disconnect();
   session.disconnect();
   while (!fmt.isInterrupted()) {
     fmt.interrupt();
   }
   System.out.println("Flexiant cloud monitor stopped!");
 }
  @Override
  public void call(final Subscriber<? super T> subscriber) {
    final Realm realm = Realm.getInstance(context);
    thread = Thread.currentThread();
    subscriber.add(
        Subscriptions.create(
            new Action0() {
              @Override
              public void call() {
                if (thread != null && !thread.isInterrupted()) {
                  thread.interrupt();
                }
              }
            }));

    boolean interrupted = false;
    boolean withError = false;

    T object = null;
    try {
      realm.beginTransaction();
      object = get(realm);
      interrupted = thread.isInterrupted();
      if (object != null && !interrupted) {
        realm.commitTransaction();
      } else {
        realm.cancelTransaction();
      }
    } catch (RuntimeException e) {
      realm.cancelTransaction();
      subscriber.onError(new RealmException("Error during transaction.", e));
      withError = true;
    } catch (Error e) {
      realm.cancelTransaction();
      subscriber.onError(e);
      withError = true;
    }
    if (!interrupted && !withError) {
      subscriber.onNext(object);
    }

    try {
      realm.close();
    } catch (RealmException ex) {
      subscriber.onError(ex);
      withError = true;
    }
    thread = null;
    if (!withError) {
      subscriber.onCompleted();
    }
    if (interrupted) {
      Thread.currentThread().interrupt();
    }
  }
示例#18
0
 /**
  * Irá forçar a parada dos downloads
  *
  * @return Retorna false se não encontrar nenhum download em andamento
  */
 public boolean stopDownload() {
   if (threadList.isEmpty()) return false;
   // Faz loop nos threads e verifica se eles ainda estão ativos e força o fechamento do mesmo
   for (Thread tr : threadList) {
     if (!tr.isInterrupted() || tr.isAlive()) {
       tr.interrupt();
       threadList.remove(tr);
     }
   }
   return true;
 }
示例#19
0
  public void stop() {
    if (recorderStarted) {
      if (recordingThread != null
          && recordingThread.isAlive()
          && !recordingThread.isInterrupted()) {
        recordingThread.interrupt();
      }

      recorderStarted = false;
    }
  }
示例#20
0
 @Override
 public void run() {
   Thread currentThread = Thread.currentThread();
   for (Map.Entry<String, InvalidationEventQueue> entry : invalidationMessageMap.entrySet()) {
     if (currentThread.isInterrupted()) {
       break;
     }
     InvalidationEventQueue invalidationMessageQueue = entry.getValue();
     if (invalidationMessageQueue.size() > 0) {
       flushInvalidationMessages(entry.getKey(), invalidationMessageQueue);
     }
   }
 }
示例#21
0
 /**
  * Called by thread which was parked after it resumes. Caller is responsible for removing node
  * from queue if return value is 0.
  *
  * @return -1 if interrupted, 0 if not signaled, 1 if signaled
  */
 final int resumed(WaitQueue queue) {
   Thread thread = mWaiter;
   if (thread == null) {
     remove(queue);
     return 1;
   }
   if (thread.isInterrupted()) {
     Thread.interrupted();
     remove(queue);
     return -1;
   }
   return 0;
 }
  /**
   * Creates all the necessary sudokus. Returns <code>false</code> if interrupted.
   *
   * @return
   */
  private boolean createSudokus() {
    int anzPuzzles = 0;
    for (int i = 0; i < numberTextFields.length; i++) {
      anzPuzzles += getNumberOfPuzzles(i);
    }
    if (anzPuzzles == 0) {
      // nothing to do
      return false;
    }
    sudokus = new Sudoku2[anzPuzzles];
    candidates = new boolean[anzPuzzles];
    int index = 0;
    for (int i = 0; i < numberTextFields.length; i++) {
      DifficultyLevel actDiffLevel =
          Options.getInstance().getDifficultyLevel(levelComboBoxes[i].getSelectedIndex() + 1);
      GameMode actGameMode = null;
      boolean withCandidates = candCheckBoxes[i].isSelected();
      switch (modeComboBoxes[i].getSelectedIndex()) {
        case 0:
          actGameMode = GameMode.PLAYING;
          break;
        case 1:
          actGameMode = GameMode.LEARNING;
          break;
        case 2:
          actGameMode = GameMode.PRACTISING;
          break;
      }
      for (int j = 0; j < getNumberOfPuzzles(i); j++) {
        sudokus[index] = getSudoku(actDiffLevel, actGameMode);
        if (sudokus[index] == null || thread.isInterrupted()) {
          return false;
        }
        candidates[index] = withCandidates;
        // put puzzle in history
        Options.getInstance().addSudokuToHistory(sudokus[index]);
        index++;
        // update progress bar
        setPercentage((int) Math.round(index * 100.0 / anzPuzzles));
        EventQueue.invokeLater(
            new Runnable() {
              @Override
              public void run() {
                setProgress();
              }
            });
      }
    }

    return true;
  }
示例#23
0
  /**
   * Loads a folder. This method should only be used by the loader thread. Otherwise this method is
   * a no-op.
   *
   * @param folder The folder to load.
   */
  public void loadFolder(final File folder) {
    final Thread t = Thread.currentThread();
    if (t != iniLoader || t.isInterrupted()) return;
    synchronized (chunks) {
      chunks.clear();
    }
    MapReader.clearCache();
    final File[] files =
        folder.listFiles(
            new FileFilter() {

              @Override
              public boolean accept(final File f) {
                return f.isFile() && f.getName().endsWith(RegionFile.ANVIL_EXTENSION);
              }
            });
    Arrays.sort(
        files,
        new Comparator<File>() {

          @Override
          public int compare(final File left, final File right) {
            final String leftStr = left.getName().replace("-", "");
            final String rightStr = right.getName().replace("-", "");
            return leftStr.compareTo(rightStr);
          }
        });
    for (final File f : files) {
      final MapReader r = MapReader.getForFile(f);
      final List<Pair> chunkList = r.getChunks();
      for (final Pair p : chunkList) {
        if (t != iniLoader || t.isInterrupted()) return;
        final Chunk chunk = new Chunk(r.read(p.x, p.z), f, p);
        unloadChunk(chunk);
      }
      user.somethingChanged();
    }
  }
示例#24
0
    public void run() {
      Thread thread = currentThread();
      if (thread.isInterrupted()) System.out.println("Нить прервана");
      while (true) {
        System.out.println(this);
        if (--countDownIndex == 0) return;
        try {
          sleep(10);
        } catch (InterruptedException e) {
        }

        // add sleep here - добавь sleep тут
      }
    }
示例#25
0
  public static void main(String[] args) {
    // sleepThread 不停的尝试睡眠
    Thread sleepThread = new Thread(new SleepRunner(), "SleepThread");
    sleepThread.setDaemon(true);

    // busyThread 不停的运行
    Thread busyThread = new Thread(new BusyRunner(), "BusyThread");
    busyThread.setDaemon(true);
    busyThread.start();

    // 休息5秒,让sleepThread 和 busyThread 充分运行
    SleepUtils.second(5);

    sleepThread.interrupt();
    busyThread.interrupt();

    System.out.println(
        "SleepThread interrupted is "
            + sleepThread.isInterrupted()); // false,InterruptException 会清除中断标识位
    System.out.println("BusyThread interrupted is " + busyThread.isInterrupted()); // true

    // 防止sleepThread 和busyThread 立刻退出
    SleepUtils.second(2);
  }
示例#26
0
 /** Print diagnostic information about currently running threads at warn level. */
 public void threadGroupList() {
   Thread[] threads = new Thread[_threads.activeCount()];
   _threads.enumerate(threads);
   for (Thread thread : threads) {
     LOGGER.warn(
         "Thread: {} [{}{}{}] ({}) {}",
         thread.getName(),
         (thread.isAlive() ? "A" : "-"),
         (thread.isDaemon() ? "D" : "-"),
         (thread.isInterrupted() ? "I" : "-"),
         thread.getPriority(),
         thread.getState());
     for (StackTraceElement s : thread.getStackTrace()) {
       LOGGER.warn("    {}", s);
     }
   }
 }
示例#27
0
 /**
  * Spins/blocks until node s is matched by a fulfill operation.
  *
  * @param s the waiting node
  * @param timed true if timed wait
  * @param nanos timeout value
  * @return matched node, or s if cancelled
  */
 SNode awaitFulfill(SNode s, boolean timed, long nanos) {
   /*
    * When a node/thread is about to block, it sets its waiter
    * field and then rechecks state at least one more time
    * before actually parking, thus covering race vs
    * fulfiller noticing that waiter is non-null so should be
    * woken.
    *
    * When invoked by nodes that appear at the point of call
    * to be at the head of the stack, calls to park are
    * preceded by spins to avoid blocking when producers and
    * consumers are arriving very close in time.  This can
    * happen enough to bother only on multiprocessors.
    *
    * The order of checks for returning out of main loop
    * reflects fact that interrupts have precedence over
    * normal returns, which have precedence over
    * timeouts. (So, on timeout, one last check for match is
    * done before giving up.) Except that calls from untimed
    * SynchronousQueue.{poll/offer} don't check interrupts
    * and don't wait at all, so are trapped in transfer
    * method rather than calling awaitFulfill.
    */
   long lastTime = timed ? System.nanoTime() : 0;
   Thread w = Thread.currentThread();
   SNode h = head;
   int spins = (shouldSpin(s) ? (timed ? maxTimedSpins : maxUntimedSpins) : 0);
   for (; ; ) {
     if (w.isInterrupted()) s.tryCancel();
     SNode m = s.match;
     if (m != null) return m;
     if (timed) {
       long now = System.nanoTime();
       nanos -= now - lastTime;
       lastTime = now;
       if (nanos <= 0) {
         s.tryCancel();
         continue;
       }
     }
     if (spins > 0) spins = shouldSpin(s) ? (spins - 1) : 0;
     else if (s.waiter == null) s.waiter = w; // establish waiter so can park next iter
     else if (!timed) LockSupport.park(this);
     else if (nanos > spinForTimeoutThreshold) LockSupport.parkNanos(this, nanos);
   }
 }
 @Override
 public void run() {
   while (!mThread.isInterrupted()) {
     try {
       Pair pair = mQueue.poll(1, TimeUnit.SECONDS);
       if (pair != null) {
         try {
           processPacket(pair.mMessage, pair.mTransmitter);
         } catch (IOException e) {
           e.printStackTrace();
         }
       }
     } catch (InterruptedException e) {
       break;
     }
   }
 }
 private void fill() throws IOException {
   for (int i = (activeBuffer + 1) % counts.length;
       i != activeBuffer && !myThread.isInterrupted();
       i = (i + 1) % counts.length) {
     if (counts[i] == 0) {
       int thisCount = fillOneBuffer(i);
       if (thisCount == -1) {
         exhausted = true;
         Thread.currentThread().interrupt();
       }
     } else {
       synchronized (lockObject) {
         lockObject.notifyAll();
       }
     }
   }
 }
示例#30
0
 @Override
 public Object eval(final Reader reader) throws ScriptException {
   setup();
   try {
     final Object filename = get(ScriptEngine.FILENAME);
     if (filename != null) put("clojure.core.*file*", filename);
     final Thread thread = Thread.currentThread();
     Object finalResult = null;
     while (!thread.isInterrupted()) {
       final Object form = LispReader.read(new PushbackReader(reader), false, this, false);
       if (form == this) break;
       finalResult = Compiler.eval(form);
     }
     return finalResult;
   } catch (final Exception e) {
     throw new ScriptException(e);
   }
 }