Exemple #1
1
  @Override
  public boolean onTouchEvent(MotionEvent event) {
    xPosition = (int) event.getX();
    yPosition = (int) event.getY();
    double abs =
        Math.sqrt(
            (xPosition - centerX) * (xPosition - centerX)
                + (yPosition - centerY) * (yPosition - centerY));
    if (abs > joystickRadius) {
      xPosition = (int) ((xPosition - centerX) * joystickRadius / abs + centerX);
      yPosition = (int) ((yPosition - centerY) * joystickRadius / abs + centerY);
    }

    invalidate();
    if (event.getAction() == MotionEvent.ACTION_UP) {
      xPosition = (int) centerX;
      yPosition = (int) centerY;
      Log.i(logTag, "ACTION_UP: " + xPosition + ", " + yPosition);
      thread.interrupt();
      onJoystickMoveListener.onValueChanged(getAngle(), getPower(), getDirection());
    }
    if (onJoystickMoveListener != null && event.getAction() == MotionEvent.ACTION_DOWN) {
      if (thread != null && thread.isAlive()) {
        thread.interrupt();
      }
      thread = new Thread(this);
      thread.start();
      onJoystickMoveListener.onValueChanged(getAngle(), getPower(), getDirection());
      Log.i(logTag, "ACTION_DOWN");
    }
    return true;
  }
 private synchronized void closeConnection() {
   stopBuffersThreads();
   if (connectedThread != null) {
     connectedThread.cancel();
     connectedThread.interrupt();
     connectedThread = null;
   }
   boolean isConnected;
   synchronized (isConnectedLock) {
     isConnected = this.isConnected;
     this.isConnected = false;
   }
   if (callbacksTimeout != null) callbacksTimeout.stopTimer();
   if (exitingCallbacksThread != null && exitingCallbacksThread.isAlive())
     exitingCallbacksThread.interrupt();
   if (enteringCallbacksThread != null && enteringCallbacksThread.isAlive())
     enteringCallbacksThread.interrupt();
   queuedFrames.clear();
   synchronized (arduinoCallbacksLock) {
     isInACallback = false;
   }
   if (isConnected) {
     Log.d("Device " + this.name + ": Device disconnected.");
     onDisconnect();
   }
 }
Exemple #3
1
 private synchronized void abort() {
   if (mode == ABORT_MODE) {
     return;
   }
   mode = ABORT_MODE;
   try {
     log.info("Aborting operation");
     if (remote_sock != null) {
       remote_sock.close();
     }
     if (sock != null) {
       sock.close();
     }
     if (relayServer != null) {
       relayServer.stop();
     }
     if (ss != null) {
       ss.close();
     }
     if (pipe_thread1 != null) {
       pipe_thread1.interrupt();
     }
     if (pipe_thread2 != null) {
       pipe_thread2.interrupt();
     }
   } catch (final IOException ioe) {
   }
 }
 private static double executeWithDisruptorPipeline(int numConsumers) {
   CountDownLatch cdl = new CountDownLatch(numConsumers);
   List<Consumer> consumers = createConsumers(numConsumers, null, cdl, SIMULATE_PROCESSING);
   MessagePipeDisruptorImpl<Carbon> pipeline =
       new MessagePipeDisruptorImpl<Carbon>(
           QUEUE_SIZE, AtomEvent.EVENT_FACTORY, new YieldingWaitStrategy(), consumers);
   Producer producer = new Producer(pipeline, NUM_MANU_UNITS);
   Thread producerThread = new Thread(producer);
   producerThread.start();
   long startTime = System.currentTimeMillis();
   try {
     cdl.await();
     printStatistics(consumers);
     long endTime = System.currentTimeMillis();
     out.println("Took " + (endTime - startTime) + " ms");
     pipeline.halt();
     producerThread.interrupt();
     while (producerThread.isAlive()) {
       out.println("Interrupting producer");
       producerThread.interrupt();
       Thread.sleep(300);
     }
     ;
     return endTime - startTime;
   } catch (InterruptedException e) {
     e.printStackTrace();
     return Double.POSITIVE_INFINITY;
   }
 }
  /**
   * 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());
    }
  }
  public void waitInternal(boolean interrupt) {
    if (queueListener.get() == null) {
      return;
    }
    if (isCurrentThread()) {
      return;
    }

    long MAX_TIMEOUT = 1000 * 10;
    long start = System.currentTimeMillis();

    while (queueListener.get().isRunning()) {
      try {
        TimeUnit.MILLISECONDS.sleep(100);

        Thread thread = queueListener.get().getThread();
        if (interrupt) {
          if (thread != null) {
            thread.interrupt();
          }
        } else if (System.currentTimeMillis() - start > MAX_TIMEOUT) {
          if (thread != null) {
            String msg = "Waited for " + MAX_TIMEOUT + "ms, will now interrupt the thread";
            log.warn(msg);
            thread.interrupt();
            throw new RuntimeException(msg);
          }
        }
      } catch (InterruptedException e) {
        log.trace("Got Interrupted while waiting for tasks.", e);
      }
    }
  }
  /**
   * Closes all the threads and frees the resources This is the last method to call before closing
   * the application
   *
   * @param sync If it is true wait the termination of the threads before returning
   */
  public void close(boolean sync) {
    terminateThread = true;
    keysDeleter.close();

    closed = true;
    if (tableUpdater != null) {
      tableUpdater.interrupt();
      if (sync) {
        try {
          // We do not want to wait forever..
          tableUpdater.join(10000);
          if (tableUpdater.isAlive()) {
            System.err.println("LogEntryTableModelBase.TableUpdater thread still alive!");
          }
        } catch (InterruptedException ie) {
        }
      }
    }
    clearAll();
    if (keysDeleterThread != null) {
      keysDeleterThread.interrupt();
      if (sync) {
        try {
          // We do not want to wait forever..
          keysDeleterThread.join(10000);
          if (keysDeleterThread.isAlive()) {
            System.err.println("LogEntryTableModelBase.KeysDeleter thread still alive!");
          }
        } catch (InterruptedException ie) {
        }
      }
    }
  }
  /**
   * @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());
  }
 private void shutdown() {
   writerRunner.shutdown();
   readerRunner.shutdown();
   if (writerThread.isAlive()) {
     writerThread.interrupt();
   }
   if (readerThread.isAlive()) {
     readerThread.interrupt();
   }
 }
  /** Run the test for the queue parameter. */
  public static SynchronizedQueueResult testQueue(QueueAdapter<Integer> queue) {
    try {
      mQueue = queue;

      // Please make sure to keep all the "TODO" comments in the
      // code below to make it easy for peer reviewers to find
      // them.

      // TODO - you fill in here to replace the null
      // initialization below to create two Java Threads, one
      // that's passed the producerRunnable and the other that's
      // passed the consumerRunnable.
      Thread consumer = new Thread(consumerRunnable);
      Thread producer = new Thread(producerRunnable);

      // TODO - you fill in here to start the threads. More
      // interesting results will occur if you start the
      // consumer first.
      producer.start();
      consumer.start();

      // Give the Threads a chance to run before interrupting
      // them.
      Thread.sleep(100);

      // TODO - you fill in here to interrupt the threads.
      producer.interrupt();
      consumer.interrupt();

      // TODO - you fill in here to wait for the threads to
      // exit.
      consumer.join();
      producer.join();
      ;

      // Do some sanity checking to see if the Threads work as
      // expected.
      if (consumer == null || producer == null)
        return SynchronizedQueueResult.THREADS_NEVER_CREATED;
      else if (consumer.isAlive() || producer.isAlive())
        return SynchronizedQueueResult.JOIN_NEVER_CALLED;
      else if (mConsumerCounter == 0 || mProducerCounter == 0)
        return SynchronizedQueueResult.THREADS_NEVER_RAN;
      else if (mConsumerCounter == mMaxIterations || mProducerCounter == mMaxIterations)
        return SynchronizedQueueResult.THREADS_NEVER_INTERUPTED;
      else if (mConsumerCounter == FAILURE_OCCURRED || mProducerCounter == FAILURE_OCCURRED)
        return SynchronizedQueueResult.THREADS_THREW_EXCEPTION;
      else if (mConsumerCounter == TIMEOUT_OCCURRED || mProducerCounter == TIMEOUT_OCCURRED)
        return SynchronizedQueueResult.THREADS_TIMEDOUT;
      else return SynchronizedQueueResult.RAN_PROPERLY;
    } catch (Exception e) {
      return SynchronizedQueueResult.TESTING_LOGIC_THREW_EXCEPTION;
    }
  }
        @Override
        public void run() {
          Thread sendingThread = null;
          Thread loggingThread = null;

          try {
            final long connectionTime = System.currentTimeMillis();
            mConnectionTime.set(connectionTime);
            reportConnect(connectionTime);

            // Launch the 'Sending' thread
            mLogger.logInfo(TAG, "Starting sender thread.");
            sendingThread = new Thread(mSendingTask, "MavLinkConnection-Sending Thread");
            sendingThread.start();

            // Launch the 'Logging' thread
            mLogger.logInfo(TAG, "Starting logging thread.");
            loggingThread = new Thread(mLoggingTask, "MavLinkConnection-Logging Thread");
            loggingThread.start();

            final Parser parser = new Parser();
            parser.stats.mavlinkResetStats();

            final byte[] readBuffer = new byte[READ_BUFFER_SIZE];

            while (mConnectionStatus.get() == MAVLINK_CONNECTED) {
              int bufferSize = readDataBlock(readBuffer);
              handleData(parser, bufferSize, readBuffer);
            }
          } catch (IOException e) {
            // Ignore errors while shutting down
            if (mConnectionStatus.get() != MAVLINK_DISCONNECTED) {
              reportComError(e.getMessage());
              mLogger.logErr(TAG, e);
            }
          } finally {
            if (sendingThread != null && sendingThread.isAlive()) {
              sendingThread.interrupt();
            }

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

            disconnect();
            mLogger.logInfo(TAG, "Exiting manager thread.");
          }
        }
Exemple #12
0
  public static void main(String[] args) {
    Bucket bucket = new Bucket(123);
    Thread consumerThread = new Thread(new Consumer(bucket));
    Thread producerThread = new Thread(new Producer(bucket));

    consumerThread.start();
    producerThread.start();

    try {
      Thread.sleep(1000);
    } catch (InterruptedException ignored) {
    }

    consumerThread.interrupt();
    producerThread.interrupt();

    try {
      consumerThread.join();
    } catch (InterruptedException e) {
      e.printStackTrace();
    }

    try {
      producerThread.join();
    } catch (InterruptedException e) {
      e.printStackTrace();
    }

    System.out.println("all threads are stopped");
    System.out.println(bucket);
  }
  /** Chiude la connessione. Chiude il socket e ferma tutti i background threads. */
  public void close() {
    boolean oldStatus = open;
    Log.d(TAG, "connection close requested");

    if (requestThread != null) {
      requestThread
          .interrupt(); // nel Thread il metodo Thread.sleep() genera una InterruptedException
    }

    if (receiveThread != null) {
      receiveThread
          .interrupt(); // nel Thread il metodo Thread.sleep() genera una InterruptedException
    }

    if (socket != null) {
      try {
        socket.close();
      } catch (IOException e) {
        e.printStackTrace();
      }
    }

    open = false;

    fireStatusChanged(oldStatus, false);
    Log.d(TAG, "connection has been closed");
  }
Exemple #14
0
 public void dispose() {
   try {
     _clientSocket.close();
   } catch (Exception e) {
     // ignore
   }
   try {
     _deviceSocket.close();
   } catch (Exception e) {
     // ignore
   }
   try {
     clientThread.interrupt();
   } catch (Exception e) {
     // ignore
   }
   try {
     deviceThread.interrupt();
   } catch (Exception e) {
     // ignore
   }
   _clientSocket = null;
   clientThread = null;
   _deviceSocket = null;
   deviceThread = null;
   clientServer = null;
   deviceServer = null;
 }
  public static void main(String[] args) throws InterruptedException {

    Object lock = new Object();
    RunEven runEven = new RunEven();
    runEven.setLock(lock);
    Thread tEven = new Thread(runEven, "runEven");
    /*Thread tOdd1 = new Thread( runEven);
    Thread tOdd2 = new Thread( runEven);*/

    RunOdd runOdd = new RunOdd();
    runOdd.setLock(lock);
    Thread tOdd = new Thread(runOdd, "runOdd");
    // RunEven.getAnInt(1);
    // RunOdd.getAnInt(9);
    /*Thread tEven1 = new Thread( runOdd);
            Thread tEven2 = new Thread( runOdd);
    */
    tEven.start();
    // RunEven.getAnInt(4);
    // tEven1.start();
    // tEven2.start();
    // Thread.sleep(1000);
    tOdd.start();
    // RunOdd.getAnInt(5);
    // tOdd1.start();
    // tOdd2.start();
    tEven.join();
    System.out.println("All printing Done !! ");
    tEven.interrupt();
    tOdd.interrupt();
  }
Exemple #16
0
  public static void stopPCconectado() {
    try {
      t2.interrupt();
      t.interrupt();
    } catch (Exception e) {

    }
  }
Exemple #17
0
 /* (non-Javadoc)
  * @see ch.inf.vs.californium.network.connector.Connector#stop()
  */
 @Override
 public synchronized void stop() {
   if (!running) return;
   running = false;
   senderThread.interrupt();
   receiverThread.interrupt();
   outgoing.clear();
 }
  public void stop() throws IOException {
    receiverThread.interrupt();
    emitterThread.interrupt();

    if (!socket.isClosed()) {
      socket.close();
    }
  }
  /** Stop the internal threads */
  public void stop() {

    // Stop the Threads
    toReceive.interrupt();
    toSend.interrupt();

    // Disconnect from the service
    communicationsVPNConnection.close();
  }
 @Override
 public void destroy() {
   Thread thread = _pipeThread;
   if (thread != null) {
     thread.interrupt();
   }
   thread = _adminShellThread;
   if (thread != null) {
     thread.interrupt();
   }
 }
Exemple #21
0
 @Override
 public void onDestroy() {
   if (clientThread0 != null) {
     clientThread0.interrupt();
     clientThread0 = null;
   }
   if (clientThread1 != null) {
     clientThread1.interrupt();
     clientThread1 = null;
   }
   Log.d(tag, "Socket RaspberryPi onDestroy");
   super.onDestroy();
 }
  @Test
  public void testNewSubNotBlockedByTimeoutTask() throws Exception {
    // Default config is 1s interval, 300s timeout.

    // Create a topic
    String testName = "AutoAckTopicTest.testNewSubNotBlockedByTimeoutTask";
    TopicDeployment deployment = new TopicDeployment();
    deployment.setDuplicatesAllowed(true);
    deployment.setDurableSend(false);
    deployment.setName(testName);
    manager.getTopicManager().deploy(deployment);

    // Create a consumer
    ClientRequest request = new ClientRequest(TestPortProvider.generateURL("/topics/" + testName));
    ClientResponse<?> response = request.head();
    response.releaseConnection();
    Assert.assertEquals(200, response.getStatus());
    Link sender = getLinkByTitle(manager.getTopicManager().getLinkStrategy(), response, "create");
    Link subscriptions =
        getLinkByTitle(manager.getTopicManager().getLinkStrategy(), response, "pull-subscriptions");

    // Create the pull-subscription itself.
    ClientResponse<?> res = subscriptions.request().post();
    res.releaseConnection();
    Assert.assertEquals(201, res.getStatus());
    Link sub1 = res.getLocationLink();
    Assert.assertNotNull(sub1);
    Link consumeNext1 =
        getLinkByTitle(manager.getTopicManager().getLinkStrategy(), res, "consume-next");
    Assert.assertNotNull(consumeNext1);

    // Pull on the topic for 8s (long enoguh to guarantee the rest of the test
    // will pass/fail due to the timeouttask + test operations)
    AcceptWaitListener awlistener = new AcceptWaitListener(consumeNext1.getHref());
    Thread t = new Thread(awlistener);
    t.start();
    // Wait 2 seconds to ensure a new TimeoutTask is running concurrently.
    Thread.sleep(2000);
    // Attempt to create a new pull-subscription. Validate that it takes no longer than 2 seconds
    // (it should take like 20ms, but give it a relatively huge amount of leeway)
    NewPullSubscriber nps = new NewPullSubscriber(subscriptions.getHref());
    Thread npsThread = new Thread(nps);
    npsThread.start();
    Thread.sleep(2000);
    Assert.assertTrue("NewPullSubscriber did not finish in 2 seconds!", nps.isFinished());
    Assert.assertFalse("AcceptWaitListener failed to open connection!", awlistener.isFailed());
    Assert.assertFalse("NewPullSubscriber failed to open new subscription!", nps.isFailed());
    npsThread.interrupt();
    t.interrupt();
  }
  public static void main(String[] args) throws Exception {
    int counter = 0;
    while (true) {
      Thread outThread = null;
      Thread errThread = null;
      try {
        // org.pitest.mutationtest.instrument.MutationTestUnit#runTestInSeperateProcessForMutationRange

        // *** start slave

        ServerSocket commSocket = new ServerSocket(0);
        int commPort = commSocket.getLocalPort();
        System.out.println("commPort = " + commPort);

        // org.pitest.mutationtest.execute.MutationTestProcess#start
        //   - org.pitest.util.CommunicationThread#start
        FutureTask<Integer> commFuture = createFuture(commSocket);
        //   - org.pitest.util.WrappingProcess#start
        //       - org.pitest.util.JavaProcess#launch
        Process slaveProcess = startSlaveProcess(commPort);
        outThread = new Thread(new ReadFromInputStream(slaveProcess.getInputStream()), "stdout");
        errThread = new Thread(new ReadFromInputStream(slaveProcess.getErrorStream()), "stderr");
        outThread.start();
        errThread.start();

        // *** wait for slave to die

        // org.pitest.mutationtest.execute.MutationTestProcess#waitToDie
        //    - org.pitest.util.CommunicationThread#waitToFinish
        System.out.println("waitToFinish");
        Integer controlReturned = commFuture.get();
        System.out.println("controlReturned = " + controlReturned);
        // NOTE: the following won't get called if commFuture.get() fails!
        //    - org.pitest.util.JavaProcess#destroy
        outThread.interrupt(); // org.pitest.util.AbstractMonitor#requestStop
        errThread.interrupt(); // org.pitest.util.AbstractMonitor#requestStop
        slaveProcess.destroy();
      } catch (Exception e) {
        e.printStackTrace(System.out);
      }

      // test: the threads should exit eventually
      outThread.join();
      errThread.join();
      counter++;
      System.out.println("try " + counter + ": stdout and stderr threads exited normally");
    }
  }
Exemple #24
0
  public static void main(String[] args) {
    final ObjectDemo demo = new ObjectDemo();

    Runnable runA =
        new Runnable() {

          public void run() {
            try {
              String item = demo.removeElement();
              System.out.println("" + item);
            } catch (InterruptedException ix) {
              System.out.println("Interrupted Exception!");
            } catch (Exception x) {
              System.out.println("Exception thrown.");
            }
          }
        };

    Runnable runB =
        new Runnable() {

          // run adds an element in the list and starts the loop
          public void run() {
            demo.addElement("Hello!");
          }
        };

    try {
      Thread threadA1 = new Thread(runA, "A");
      threadA1.start();

      Thread.sleep(500);

      Thread threadA2 = new Thread(runA, "B");
      threadA2.start();

      Thread.sleep(500);

      Thread threadB = new Thread(runB, "C");
      threadB.start();

      Thread.sleep(1000);

      threadA1.interrupt();
      threadA2.interrupt();
    } catch (InterruptedException x) {
    }
  }
 /**
  * A new method that interrupts the worker thread. Call this method to force the worker to stop
  * what it's doing.
  */
 public void interrupt() {
   Thread t = threadVar.get();
   if (t != null) {
     t.interrupt();
   }
   threadVar.clear();
 }
Exemple #26
0
 protected void cancelThread() {
   if (thread != null) {
     thread.interrupt();
   }
   mHandler.removeCallbacks(r);
   hiddenProgressToolBar();
 }
  /** {@inheritDoc} */
  @SuppressWarnings("deprecation")
  public void stop() {
    this.isRunning_ = false;

    if (this.isListening_ == false) {
      try {
        //  通信用ポートBind待ち状態のために、割り込みを行う
        Thread acceptThread = this.acceptThread_;
        if (acceptThread != null) {
          acceptThread.interrupt();
        }
      } catch (Exception ex) {
        LOGGER.warn(ex);
      }
    }

    if (this.isListening_) {
      // 待ち受けソケットを閉じることにより、accept()でSocketExceptionが
      // 発生し、待ち受けスレッドが停止する。
      if (this.objServerSocket_ != null) {
        try {
          this.objServerSocket_.close();
        } catch (Exception ex) {
          LOGGER.warn(ex);
        }
      }

      this.isListening_ = false;
    }
  }
 public synchronized void stop() {
   running = false;
   if (runThread != null) {
     runThread.interrupt();
   }
   runThread = null;
 }
  /**
   * Closes all connected clients sockets, then closes the underlying ServerSocketChannel,
   * effectively killing the server socket selectorthread, freeing the port the server was bound to
   * and stops all internal workerthreads.
   *
   * <p>If this method is called before the server is started it will never start.
   *
   * @param timeout Specifies how many milliseconds shall pass between initiating the close
   *     handshakes with the connected clients and closing the servers socket channel.
   * @throws IOException When {@link ServerSocketChannel}.close throws an IOException
   * @throws InterruptedException
   */
  public void stop(int timeout) throws IOException, InterruptedException {
    if (!isclosed.compareAndSet(false, true)) {
      return;
    }

    synchronized (connections) {
      for (WebSocket ws : connections) {
        ws.close(CloseFrame.GOING_AWAY);
      }
    }
    synchronized (this) {
      if (selectorthread != null) {
        if (Thread.currentThread() != selectorthread) {}

        if (selectorthread != Thread.currentThread()) {
          selectorthread.interrupt();
          selectorthread.join();
        }
      }
      if (decoders != null) {
        for (WebSocketWorker w : decoders) {
          w.interrupt();
        }
      }
      if (server != null) {
        server.close();
      }
    }
  }
Exemple #30
0
  /** Stop montioring the Launchpad controls. */
  public void Stop() {
    Util.consoleLog();

    if (monitorLaunchPadThread != null) monitorLaunchPadThread.interrupt();

    monitorLaunchPadThread = null;
  }