Пример #1
1
 private void shutdown() {
   writerRunner.shutdown();
   readerRunner.shutdown();
   if (writerThread.isAlive()) {
     writerThread.interrupt();
   }
   if (readerThread.isAlive()) {
     readerThread.interrupt();
   }
 }
Пример #2
1
    // 检查任务是否结束
    private boolean isTaskFinished() {
      // 如果reader 或 writer没有完成工作,那么直接返回工作没有完成
      if (readerThread.isAlive() || writerThread.isAlive()) {
        return false;
      }

      if (taskCommunication == null || !taskCommunication.isFinished()) {
        return false;
      }

      return true;
    }
Пример #3
0
  @Test
  public void concurrent_first_key() {
    DB db = DBMaker.memoryDB().transactionDisable().make();
    final BTreeMap m = db.treeMap("name");

    // fill
    final int c = 1000000 * TT.scale();
    for (int i = 0; i <= c; i++) {
      m.put(i, i);
    }

    Thread t =
        new Thread() {
          @Override
          public void run() {
            for (int i = 0; i <= c; i++) {
              m.remove(c);
            }
          }
        };
    t.run();
    while (t.isAlive()) {
      assertNotNull(m.firstKey());
    }
  }
  /// The watcher thread - from the Runnable interface.
  // This has to be pretty anal to avoid monitor lockup, lost
  // threads, etc.
  public synchronized void run() {
    Thread me = Thread.currentThread();
    me.setPriority(Thread.MAX_PRIORITY);

    ThreadMXBean threadMXBean = ManagementFactory.getThreadMXBean();
    startTimeInNs = threadMXBean.getCurrentThreadCpuTime();

    if (enabled.get()) {
      do {
        loop.set(false);
        try {
          wait(millis);
        } catch (InterruptedException e) {
        }
      } while (enabled.get() && loop.get());
    }

    if (enabled.get() && targetThread.isAlive()) {
      isDoneRunning.set(true);

      printThread();
      if (kill) {
        logger.warn(
            "Trying to kill thread with id:"
                + targetThread.getId()
                + " but did not as it can cause deadlocks etc.");
        // targetThread.interrupt();
        // targetThread.stop(); //Never kill thread - it can cause other problems
      }
      done();
      isDoneRunning.set(false);
    }
  }
  /** compareAndSet in one thread enables another waiting for value to succeed */
  public void testCompareAndSetInMultipleThreads() throws Exception {
    x = one;
    final AtomicReferenceFieldUpdater<AtomicReferenceFieldUpdaterTest, Integer> a;
    try {
      a =
          AtomicReferenceFieldUpdater.newUpdater(
              AtomicReferenceFieldUpdaterTest.class, Integer.class, "x");
    } catch (RuntimeException ok) {
      return;
    }

    Thread t =
        new Thread(
            new CheckedRunnable() {
              public void realRun() {
                while (!a.compareAndSet(AtomicReferenceFieldUpdaterTest.this, two, three))
                  Thread.yield();
              }
            });

    t.start();
    assertTrue(a.compareAndSet(this, one, two));
    t.join(LONG_DELAY_MS);
    assertFalse(t.isAlive());
    assertSame(a.get(this), three);
  }
Пример #6
0
 private void timeoutIfStillRunning(Thread t) {
   if (t.isAlive()) {
     log.warn("Scenario timed out after " + scenarioTimeoutMillis + " millis, will interrupt");
     stepProcessor.setInterruptingOnTimeout(true);
     t.interrupt(); // first try to interrupt to see if this can unblock/fail the scenario
   }
 }
Пример #7
0
  @Override
  protected synchronized void onSizeChanged(int w, int h, int oldw, int oldh) {

    // update pixel conversion values
    PixelUtils.init(getContext());

    // disable hardware acceleration if it's not explicitly supported
    // by the current Plot implementation. this check only applies to
    // honeycomb and later environments.
    if (Build.VERSION.SDK_INT >= 11) {
      if (!isHwAccelerationSupported() && isHardwareAccelerated()) {
        setLayerType(View.LAYER_TYPE_SOFTWARE, null);
      }
    }

    // pingPong is only used in background rendering mode.
    if (renderMode == RenderMode.USE_BACKGROUND_THREAD) {
      pingPong.resize(h, w);
    }

    RectF cRect = new RectF(0, 0, w, h);
    RectF mRect = boxModel.getMarginatedRect(cRect);
    RectF pRect = boxModel.getPaddedRect(mRect);

    layout(new DisplayDimensions(cRect, mRect, pRect));
    super.onSizeChanged(w, h, oldw, oldh);
    if (renderThread != null && !renderThread.isAlive()) {
      renderThread.start();
    }
  }
Пример #8
0
 private void killInterpreterIfStillRunning(Thread t) {
   if (t.isAlive()) {
     log.error(
         "Scenario did not respond to thread.kill() after timeout, will now kill the interpreter");
     System.exit(1);
   }
 }
Пример #9
0
  /**
   * This starts the layout thread, it does not run before this. Note this is a background check it
   * doesn't stop when done it just sleeps until it gets more work.
   */
  public void start() {

    if (controller != null && !runner.isAlive() && !pauseState) {
      active = true;
      runner.start();
    }
  }
Пример #10
0
    /**
     * @param views Guaranteed to be non-null and to have >= 2 members, or else this thread would
     *     not be started
     */
    public synchronized void start(Map<Address, View> views) {
      if (thread == null || thread.isAlive()) {
        this.coords.clear();

        // now remove all members which don't have us in their view, so RPCs won't block (e.g.
        // FLUSH)
        // https://jira.jboss.org/browse/JGRP-1061
        sanitizeViews(views);

        // Add all different coordinators of the views into the hashmap and sets their members:
        Collection<Address> coordinators = Util.determineMergeCoords(views);
        for (Address coord : coordinators) {
          View view = views.get(coord);
          if (view != null) this.coords.put(coord, new ArrayList<Address>(view.getMembers()));
        }

        // For the merge participants which are not coordinator, we simply add them, and the
        // associated
        // membership list consists only of themselves
        Collection<Address> merge_participants = Util.determineMergeParticipants(views);
        merge_participants.removeAll(coordinators);
        for (Address merge_participant : merge_participants) {
          Collection<Address> tmp = new ArrayList<Address>();
          tmp.add(merge_participant);
          coords.putIfAbsent(merge_participant, tmp);
        }

        thread = gms.getThreadFactory().newThread(this, "MergeTask");
        thread.setDaemon(true);
        thread.start();
      }
    }
Пример #11
0
  public void getRepeaterIDCallBack(Map<String, Integer> repeaterids) throws Exception {
    log.info("getRepeaterIDCallBack");
    if (screenshareflag) {

      if (!looThread.isAlive()) {
        looThread.start();
      }

      Iterator<Entry<String, Integer>> iterator = repeaterids.entrySet().iterator();
      while (iterator.hasNext()) {
        Map.Entry<java.lang.String, java.lang.Integer> entry =
            (Map.Entry<java.lang.String, java.lang.Integer>) iterator.next();
        String remoteUserName = entry.getKey().substring(entry.getKey().indexOf("-") + 1);
        if (!remoteUserName.equals(DataUtil.getLoginInfo().getUsername())) {
          addToWaitList(remoteUserName, entry.getValue() + "", true);
        }
      }

      //			DockingLayoutMeetingPanel panel =
      // DataUtil.getValue(DataUtil.Key.DockingLayoutMeetingPanel);
      //			panel.getStartScreenShareMI().setEnabled(false);
      //			panel.getStopScreenShareMI().setEnabled(true);
      MainFrame mainFrame = ViewManager.getComponent(MainFrame.class);
      mainFrame
          .getShareDesktopButton()
          .setText(StringUtil.getUIString("DockingLayoutMeetingPanel.stopScreenShareMI.text"));
      mainFrame.getShareDesktopButton().setEnabled(true);

      //    		screenshareflag = false;
    }
  }
Пример #12
0
  /** Stops unicast and multicast receiver threads */
  void stopThreads() {
    Thread tmp;

    // 1. Stop the multicast receiver thread
    if (mcast_receiver != null) {
      if (mcast_receiver.isAlive()) {
        tmp = mcast_receiver;
        mcast_receiver = null;
        closeMulticastSocket(); // will cause the multicast thread to terminate
        tmp.interrupt();
        try {
          tmp.join(100);
        } catch (Exception e) {
        }
        tmp = null;
      }
      mcast_receiver = null;
    }

    // 2. Stop the unicast receiver thread
    if (ucast_receiver != null) {
      ucast_receiver.stop();
      ucast_receiver = null;
    }

    // 3. Stop the in_packet_handler thread
    if (incoming_packet_handler != null) {
      incoming_packet_handler.stop();
    }
  }
Пример #13
0
 synchronized void start() {
   if (queue.closed()) queue.reset();
   if (thread == null || !thread.isAlive()) {
     thread = getThreadFactory().newThread(this, "ViewHandler");
     thread.setDaemon(
         false); // thread cannot terminate if we have tasks left, e.g. when we as coord leave
     thread.start();
   }
 }
 /** Spin-waits until sync.isQueued(t) becomes true. */
 void waitForQueuedThread(AbstractQueuedLongSynchronizer sync, Thread t) {
   long startTime = System.nanoTime();
   while (!sync.isQueued(t)) {
     if (millisElapsedSince(startTime) > LONG_DELAY_MS)
       throw new AssertionFailedError("timed out");
     Thread.yield();
   }
   assertTrue(t.isAlive());
 }
Пример #15
0
 private void stopThreadIfStillRunning(Thread t) {
   if (t.isAlive()) {
     log.error(
         "Scenario did not respond to interrupt after timeout, "
             + "will stop the interpreter thread and fail the tests");
     t.stop(); // this will trigger a ThreadDeath exception which we should allow to propagate
     // and will terminate the interpreter
   }
 }
  /* Add a new shutdown hook.  Checks the shutdown state and the hook itself,
   * but does not do any security checks.
   */
  static synchronized void add(Thread hook) {
    if (hooks == null) throw new IllegalStateException("Shutdown in progress");

    if (hook.isAlive()) throw new IllegalArgumentException("Hook already running");

    if (hooks.containsKey(hook)) throw new IllegalArgumentException("Hook previously registered");

    hooks.put(hook, hook);
  }
Пример #17
0
 public synchronized void handle(Socket socket) throws IOException {
   con = new Connection(socket);
   count = 0;
   if (thread == null || !thread.isAlive()) {
     thread = new Thread(runners, this);
     thread.start();
   } else {
     notify();
   }
 }
Пример #18
0
 public void alert() {
   if (isUpnpDevice(uuid)
       && (monitor == null || !monitor.isAlive())
       && !"STOPPED".equals(data.get("TransportState"))) {
     monitor();
   }
   for (ActionListener l : listeners) {
     l.actionPerformed(event);
   }
 }
Пример #19
0
 /** This initializes the runner thread. */
 private void initThread() {
   if (runner == null || !runner.isAlive()) {
     runner = new Thread(this, "WeightedElasticLayoutThread");
     stable = false;
     idleing = false;
     active = false;
   } else {
     System.err.println("WeightedElasticLayoutThread Error: Trying to Re-initialize thread");
   }
 }
Пример #20
0
 public void stop() {
   Thread tmp;
   if (thread != null && thread.isAlive()) {
     running = false;
     tmp = thread;
     thread = null;
     closeSocket(); // this will cause the thread to break out of its loop
     tmp.interrupt();
     tmp = null;
   }
   thread = null;
 }
 public boolean runMacroTool(String name) {
   for (int i = 0; i < nMacros; i++) {
     if (macroNames[i].startsWith(name)) {
       if (macroToolThread != null
           && macroToolThread.getName().indexOf(name) != -1
           && macroToolThread.isAlive())
         return false; // do nothing if this tool is already running
       MacroRunner mw = new MacroRunner(pgm, macroStarts[i], name, (String) null);
       macroToolThread = mw.getThread();
       // IJ.log("runMacroTool: "+macroToolThread);
       return true;
     }
   }
   return false;
 }
Пример #22
0
  static void test() throws Throwable {
    final ExecutorService executor = Executors.newCachedThreadPool();

    final NotificationReceiver notifiee1 = new NotificationReceiver();
    final NotificationReceiver notifiee2 = new NotificationReceiver();

    final Collection<Callable<Object>> tasks = new ArrayList<Callable<Object>>();
    tasks.add(new BlockingTask(notifiee1));
    tasks.add(new BlockingTask(notifiee2));
    tasks.add(new NonBlockingTask());

    // start a thread to invoke the tasks
    Thread thread =
        new Thread() {
          public void run() {
            try {
              executor.invokeAll(tasks);
            } catch (RejectedExecutionException t) {
              /* OK */
            } catch (Throwable t) {
              unexpected(t);
            }
          }
        };
    thread.start();

    // Wait until tasks begin execution
    notifiee1.waitForNotification();
    notifiee2.waitForNotification();

    // Now try to shutdown the executor service while tasks
    // are blocked.  This should cause the tasks to be
    // interrupted.
    executor.shutdownNow();
    if (!executor.awaitTermination(5, TimeUnit.SECONDS)) throw new Error("Executor stuck");

    // Wait for the invocation thread to complete.
    thread.join(1000);
    if (thread.isAlive()) {
      thread.interrupt();
      thread.join(1000);
      throw new Error("invokeAll stuck");
    }
  }
Пример #23
0
 /** This stops the layout if it's running, if it's not running it does nothing... */
 public void stop() {
   if (runner.isAlive()) {
     try {
       active = false;
       if (idleing) {
         runner.interrupt();
       }
       System.out.println(
           "Thread "
               + Thread.currentThread().getName()
               + " Ordering thread layout thread to stop.");
       runner.join();
       initThread();
     } catch (InterruptedException ex) {
       System.err.println("Layout Thread failed to stop");
       Logger.getLogger(WeightedElasticLayout.class.getName()).log(Level.SEVERE, null, ex);
     }
   }
 }
  /**
   * Ensure that the message loop thread is running. This method simply returns if the thread is
   * already running. It creates a new thread if the message thread is not running. This method does
   * not return until the message loop is initialized and ready for use.
   */
  protected void ensureMessageLoopRunning() {
    synchronized (webViewUILock) {
      if (webViewUI == null || !webViewUI.isAlive()) {
        webViewMessageLoop = 0;

        // Create a new thread to run the web view message loop.
        webViewUI =
            new Thread("WebView UI") {
              public void run() {
                try {
                  // Create a message loop in native code. This call must return
                  // before any messages are sent to the WebView.
                  webViewMessageLoop = WindowsWebViewJNI.newMessageLoop();
                } catch (Throwable t) {
                  webViewMessageLoop = -1;
                } finally {
                  // Notify the outer thread that the message loop is ready or failed to start.
                  synchronized (webViewUILock) {
                    webViewUILock.notify();
                  }
                }

                // Process messages in native code until the message loop
                // is terminated.
                WindowsWebViewJNI.runMessageLoop(webViewMessageLoop);
              }
            };
        webViewUI.start();

        // Wait for the newly started thread to create the message loop. We cannot
        // safely use the WebView until the message loop has been initialized.
        while (webViewMessageLoop == 0) {
          try {
            webViewUILock.wait(1000);
          } catch (InterruptedException ignored) {
          }
        }
      }
    }
  }
Пример #25
0
  /** Starts the unicast and multicast receiver threads */
  void startThreads() throws Exception {
    if (ucast_receiver == null) {
      // start the listener thread of the ucast_recv_sock
      ucast_receiver = new UcastReceiver();
      ucast_receiver.start();
      if (Trace.trace) {
        Trace.info("UDP.startThreads()", "created unicast receiver thread");
      }
    }

    if (ip_mcast) {
      if (mcast_receiver != null) {
        if (mcast_receiver.isAlive()) {
          if (Trace.trace) {
            Trace.info(
                "UDP.createThreads()",
                "did not create new multicastreceiver thread as existing "
                    + "multicast receiver thread is still running");
          }
        } else {
          mcast_receiver = null; // will be created just below...
        }
      }

      if (mcast_receiver == null) {
        mcast_receiver = new Thread(this, "UDP mcast receiver");
        mcast_receiver.setPriority(Thread.MAX_PRIORITY); // needed ????
        mcast_receiver.setDaemon(true);
        mcast_receiver.start();
      }
    }
    if (use_outgoing_packet_handler) {
      outgoing_packet_handler.start();
    }
    if (use_incoming_packet_handler) {
      incoming_packet_handler.start();
    }
  }
Пример #26
0
 public boolean isAlive() {
   return thread.isAlive();
 }
Пример #27
0
 public synchronized void stop() {
   Thread tmp = thread;
   if (thread != null && thread.isAlive()) tmp.interrupt();
   thread = null;
 }
Пример #28
0
 /**
  * Returns true if the layout is running, false if it's stopped or paused or ...
  *
  * @return true if running false otherwise.
  */
 public boolean isRunning() {
   return runner.isAlive();
 }
Пример #29
0
  /**
   * Try to update an old block to a new block. If there are ongoing create threads running for the
   * old block, the threads will be returned without updating the block.
   *
   * @return ongoing create threads if there is any. Otherwise, return null.
   */
  private synchronized List<Thread> tryUpdateBlock(Block oldblock, Block newblock)
      throws IOException {
    // check ongoing create threads
    final ActiveFile activefile = ongoingCreates.get(oldblock);
    if (activefile != null && !activefile.threads.isEmpty()) {
      // remove dead threads
      for (Iterator<Thread> i = activefile.threads.iterator(); i.hasNext(); ) {
        final Thread t = i.next();
        if (!t.isAlive()) {
          i.remove();
        }
      }

      // return living threads
      if (!activefile.threads.isEmpty()) {
        return new ArrayList<Thread>(activefile.threads);
      }
    }

    // No ongoing create threads is alive. Update block.
    File blockFile = findBlockFile(oldblock.getBlockId());
    if (blockFile == null) {
      throw new IOException("Block " + oldblock + " does not exist.");
    }

    File oldMetaFile = findMetaFile(blockFile);
    long oldgs = parseGenerationStamp(blockFile, oldMetaFile);

    // rename meta file to a tmp file
    File tmpMetaFile =
        new File(
            oldMetaFile.getParent(),
            oldMetaFile.getName() + "_tmp" + newblock.getGenerationStamp());
    if (!oldMetaFile.renameTo(tmpMetaFile)) {
      throw new IOException("Cannot rename block meta file to " + tmpMetaFile);
    }

    // update generation stamp
    if (oldgs > newblock.getGenerationStamp()) {
      throw new IOException(
          "Cannot update block (id="
              + newblock.getBlockId()
              + ") generation stamp from "
              + oldgs
              + " to "
              + newblock.getGenerationStamp());
    }

    // update length
    if (newblock.getNumBytes() > oldblock.getNumBytes()) {
      throw new IOException(
          "Cannot update block file (="
              + blockFile
              + ") length from "
              + oldblock.getNumBytes()
              + " to "
              + newblock.getNumBytes());
    }
    if (newblock.getNumBytes() < oldblock.getNumBytes()) {
      truncateBlock(blockFile, tmpMetaFile, oldblock.getNumBytes(), newblock.getNumBytes());
    }

    // rename the tmp file to the new meta file (with new generation stamp)
    File newMetaFile = getMetaFile(blockFile, newblock);
    if (!tmpMetaFile.renameTo(newMetaFile)) {
      throw new IOException("Cannot rename tmp meta file to " + newMetaFile);
    }

    updateBlockMap(ongoingCreates, oldblock, newblock);
    updateBlockMap(volumeMap, oldblock, newblock);

    // paranoia! verify that the contents of the stored block
    // matches the block file on disk.
    validateBlockMetadata(newblock);
    return null;
  }
Пример #30
0
 @Override
 public void stop() {
   if (myThread != null && myThread.isAlive()) {
     myThread.interrupt();
   }
 }