Java Daemon.interrupt方法代码示例

import org.apache.hadoop.util.Daemon; //导入方法依赖的package包/类
@Override
protected void _processEvent(InjectionEventI event, Object... args) {
  if (event == InjectionEvent.FSNAMESYSTEM_STOP_MONITOR) {
    Daemon monitor = (Daemon) args[0];
    if (monitor != null && monitor.isAlive()) {
      monitor.interrupt();
    }
  }
}
 

import org.apache.hadoop.util.Daemon; //导入方法依赖的package包/类
void receiveBlock(
    DataOutputStream mirrOut, // output to next datanode
    DataInputStream mirrIn,   // input from next datanode
    DataOutputStream replyOut,  // output to previous datanode
    String mirrAddr, DataTransferThrottler throttlerArg,
    DatanodeInfo[] downstreams) throws IOException {

    syncOnClose = datanode.getDnConf().syncOnClose;
    boolean responderClosed = false;
    mirrorOut = mirrOut;
    mirrorAddr = mirrAddr;
    throttler = throttlerArg;

  try {
    if (isClient && !isTransfer) {
      responder = new Daemon(datanode.threadGroup, 
          new PacketResponder(replyOut, mirrIn, downstreams));
      responder.start(); // start thread to processes responses
    }

    /* 
     * Receive until the last packet.
     */
    while (receivePacket() >= 0) {}

    // wait for all outstanding packet responses. And then
    // indicate responder to gracefully shutdown.
    // Mark that responder has been closed for future processing
    if (responder != null) {
      ((PacketResponder)responder.getRunnable()).close();
      responderClosed = true;
    }

    // If this write is for a replication or transfer-RBW/Finalized,
    // then finalize block or convert temporary to RBW.
    // For client-writes, the block is finalized in the PacketResponder.
    if (isDatanode || isTransfer) {
      // close the block/crc files
      close();
      block.setNumBytes(replicaInfo.getNumBytes());

      if (stage == BlockConstructionStage.TRANSFER_RBW) {
        // for TRANSFER_RBW, convert temporary to RBW
        datanode.data.convertTemporaryToRbw(block);
      } else {
        // for isDatnode or TRANSFER_FINALIZED
        // Finalize the block.
        datanode.data.finalizeBlock(block);
      }
      datanode.metrics.incrBlocksWritten();
    }

  } catch (IOException ioe) {
    LOG.info("Exception for " + block, ioe);
    throw ioe;
  } finally {
    if (!responderClosed) { // Abnormal termination of the flow above
      IOUtils.closeStream(this);
      if (responder != null) {
        responder.interrupt();
      }
      cleanupBlock();
    }
    if (responder != null) {
      try {
        responder.join(datanode.getDnConf().getXceiverStopTimeout());
        if (responder.isAlive()) {
          String msg = "Join on responder thread " + responder
              + " timed out";
          LOG.warn(msg + "\n" + StringUtils.getStackTrace(responder));
          throw new IOException(msg);
        }
      } catch (InterruptedException e) {
        responder.interrupt();
        throw new IOException("Interrupted receiveBlock");
      }
      responder = null;
    }
  }
}
 

import org.apache.hadoop.util.Daemon; //导入方法依赖的package包/类
void receiveBlock(DataOutputStream mirrOut, // output to next datanode
    DataInputStream mirrIn,   // input from next datanode
    DataOutputStream replyOut,  // output to previous datanode
    String mirrAddr, DataTransferThrottler throttlerArg,
    DatanodeInfo[] downstreams) throws IOException {

  syncOnClose = datanode.getDnConf().syncOnClose;
  boolean responderClosed = false;
  mirrorOut = mirrOut;
  mirrorAddr = mirrAddr;
  throttler = throttlerArg;

  try {
    if (isClient && !isTransfer) {
      responder = new Daemon(datanode.threadGroup,
          new PacketResponder(replyOut, mirrIn, downstreams));
      responder.start(); // start thread to processes responses
    }

    /* 
     * Receive until the last packet.
     */
    while (receivePacket() >= 0) {
    }

    // wait for all outstanding packet responses. And then
    // indicate responder to gracefully shutdown.
    // Mark that responder has been closed for future processing
    if (responder != null) {
      ((PacketResponder) responder.getRunnable()).close();
      responderClosed = true;
    }

    // If this write is for a replication or transfer-RBW/Finalized,
    // then finalize block or convert temporary to RBW.
    // For client-writes, the block is finalized in the PacketResponder.
    if (isDatanode || isTransfer) {
      // close the block/crc files
      close();
      block.setNumBytes(replicaInfo.getNumBytes());

      if (stage == BlockConstructionStage.TRANSFER_RBW) {
        // for TRANSFER_RBW, convert temporary to RBW
        datanode.data.convertTemporaryToRbw(block);
      } else {
        // for isDatnode or TRANSFER_FINALIZED
        // Finalize the block.
        datanode.data.finalizeBlock(block);
      }
      datanode.metrics.incrBlocksWritten();
    }

  } catch (IOException ioe) {
    LOG.info("Exception for " + block, ioe);
    throw ioe;
  } finally {
    if (!responderClosed) { // Abnormal termination of the flow above
      IOUtils.closeStream(this);
      if (responder != null) {
        responder.interrupt();
      }
      cleanupBlock();
    }
    if (responder != null) {
      try {
        responder.join();
      } catch (InterruptedException e) {
        responder.interrupt();
        throw new IOException("Interrupted receiveBlock");
      }
      responder = null;
    }
  }
}
 

import org.apache.hadoop.util.Daemon; //导入方法依赖的package包/类
void receiveBlock(
    DataOutputStream mirrOut, // output to next datanode
    DataInputStream mirrIn,   // input from next datanode
    DataOutputStream replyOut,  // output to previous datanode
    String mirrAddr, DataTransferThrottler throttlerArg,
    int numTargets) throws IOException {

    boolean responderClosed = false;
    mirrorOut = mirrOut;
    mirrorAddr = mirrAddr;
    throttler = throttlerArg;

  try {
    if (clientName.length() > 0) {
      responder = new Daemon(datanode.threadGroup, 
                             new PacketResponder(this, block, mirrIn, 
                                                 replyOut, numTargets,
                                                 Thread.currentThread()));
      responder.start(); // start thread to processes reponses
    }

    /* 
     * Receive until the last packet.
     */
    while (receivePacket() >= 0) {}

    // wait for all outstanding packet responses. And then
    // indicate responder to gracefully shutdown.
    // Mark that responder has been closed for future processing
    if (responder != null) {
      ((PacketResponder)responder.getRunnable()).close();
      responderClosed = true;
    }

    // if this write is for a replication request (and not
    // from a client), then finalize block. For client-writes, 
    // the block is finalized in the PacketResponder.
    if (clientName.length() == 0) {
      // close the block/crc files
      close();

      // Finalize the block. Does this fsync()?
      block.setNumBytes(replicaInfo.getNumBytes());
      datanode.data.finalizeBlock(block);
      datanode.myMetrics.blocksWritten.inc();
    }

  } catch (IOException ioe) {
    LOG.info("Exception in receiveBlock for block " + block + 
             " " + ioe);
    throw ioe;
  } finally {
    if (!responderClosed) { // Abnormal termination of the flow above
      IOUtils.closeStream(this);
      if (responder != null) {
        responder.interrupt();
      }
      cleanupBlock();
    }
    if (responder != null) {
      try {
        responder.join();
      } catch (InterruptedException e) {
        throw new IOException("Interrupted receiveBlock");
      }
      responder = null;
    }
  }
}