How to use

Daemon

in

org.apache.hadoop.util

@Override
public Thread newThread(Runnable runnable) {
 return new Daemon(runnable);
}

public void shutdown() {
 LOG.info("Stopping HealthMonitor thread");
 shouldRun = false;
 daemon.interrupt();
}

void join() throws InterruptedException {
 daemon.join();
}

responder = new Daemon(datanode.threadGroup, 
  new PacketResponder(replyOut, mirrIn, downstreams));
responder.start(); // start thread to processes responses
((PacketResponder)responder.getRunnable()).close();
responderClosed = true;
 responder.interrupt();
 responder.interrupt();
 responder.join(joinTimeout);
 if (responder.isAlive()) {
  String msg = "Join on responder thread " + responder
    + " timed out";
 responder.interrupt();

 public Daemon recoverBlocks(final String who,
   final Collection<RecoveringBlock> blocks) {
  Daemon d = new Daemon(datanode.threadGroup, new Runnable() {
   @Override
   public void run() {
    for(RecoveringBlock b : blocks) {
     try {
      logRecoverBlock(who, b);
      if (b.isStriped()) {
       new RecoveryTaskStriped((RecoveringStripedBlock) b).recover();
      } else {
       new RecoveryTaskContiguous(b).recover();
      }
     } catch (IOException e) {
      LOG.warn("recoverBlocks FAILED: " + b, e);
     }
    }
   }
  });
  d.start();
  return d;
 }
}

void stop() {
 fsRunning = false;
 if(timerThread == null) return;
 timerThread.interrupt();
 try {
  timerThread.join(3000);
 } catch (InterruptedException ie) {
 }
}

/**
 * Initializes block movement tracker daemon and starts the thread.
 */
private void startMovementTracker() {
 movementTrackerThread = new Daemon(this.blkMovementTracker);
 movementTrackerThread.setName("BlockStorageMovementTracker");
 movementTrackerThread.start();
}

Daemon daemon = new Daemon(threadGroup,
  new DataTransfer(targets, targetStorageTypes, targetStorageIds, b,
    stage, client));
daemon.start();
try {
 daemon.join();
} catch (InterruptedException e) {
 throw new IOException(

@Override // FsDatasetSpi
public void shutdown() {
 fsRunning = false;
 if (lazyWriter != null) {
  ((LazyWriter) lazyWriter.getRunnable()).stop();
  lazyWriter.interrupt();
 }
 if (mbeanName != null) {
  MBeans.unregister(mbeanName);
 }
 
 if (asyncDiskService != null) {
  asyncDiskService.shutdown();
 }
 if (asyncLazyPersistService != null) {
  asyncLazyPersistService.shutdown();
 }
 
 if(volumes != null) {
  volumes.shutdown();
 }
 if (lazyWriter != null) {
  try {
   lazyWriter.join();
  } catch (InterruptedException ie) {
   LOG.warn("FsDatasetImpl.shutdown ignoring InterruptedException " +
          "from LazyWriter.join");
  }
 }
}

if (dumpThread != null && dumpThread.isAlive()) {
 dumpThread.interrupt();
 try {
  dumpThread.join(3000);
 } catch (InterruptedException ignored) {

/** Construct a daemon thread. */
public Daemon(Runnable runnable) {
 super(runnable);
 this.runnable = runnable;
 this.setName(((Object)runnable).toString());
}

public void activate(Configuration conf, long blockTotal) {
 pendingReconstruction.start();
 datanodeManager.activate(conf);
 this.redundancyThread.setName("RedundancyMonitor");
 this.redundancyThread.start();
 storageInfoDefragmenterThread.setName("StorageInfoMonitor");
 storageInfoDefragmenterThread.start();
 this.blockReportThread.start();
 mxBeanName = MBeans.register("NameNode", "BlockStats", this);
 bmSafeMode.activate(blockTotal);
}

leaseManager.stopMonitor();
if (nnrmthread != null) {
 ((NameNodeResourceMonitor) nnrmthread.getRunnable()).stopMonitor();
 nnrmthread.interrupt();
 ((NameNodeEditLogRoller)nnEditLogRoller.getRunnable()).stop();
 nnEditLogRoller.interrupt();
 ((LazyPersistFileScrubber) lazyPersistFileScrubber.getRunnable()).stop();
 lazyPersistFileScrubber.interrupt();

void start() {
 daemon.start();
}

boolean isAlive() {
 return daemon.isAlive();
}

@Override // ClientDatanodeProtocol
public long getBalancerBandwidth() {
 DataXceiverServer dxcs =
           (DataXceiverServer) this.dataXceiverServer.getRunnable();
 return dxcs.balanceThrottler.getBandwidth();
}

responder = new Daemon(datanode.threadGroup, 
  new PacketResponder(replyOut, mirrIn, downstreams));
responder.start(); // start thread to processes responses
((PacketResponder)responder.getRunnable()).close();
responderClosed = true;
 responder.interrupt();
 responder.interrupt();
 responder.join(joinTimeout);
 if (responder.isAlive()) {
  String msg = "Join on responder thread " + responder
    + " timed out";
 responder.interrupt();

private void startDiskOutlierDetectionThread() {
 slowDiskDetectionDaemon = new Daemon(new Runnable() {
  @Override
  public void run() {
 slowDiskDetectionDaemon.start();

void close() {
 heartbeatThread.interrupt();
 try {
  // This will no effect if the thread hasn't yet been started.
  heartbeatThread.join(3000);
 } catch (InterruptedException ignored) {
 }
}

public void activate() {
 pathIdCollector = new Daemon(pathIDProcessor);
 pathIdCollector.setName("SPSPathIdProcessor");
 pathIdCollector.start();
}