Java Daemon.DaemonFactory方法代码示例

import org.apache.hadoop.util.Daemon; //导入方法依赖的package包/类
private void initializeStripedReadThreadPool(int num) {
  if (LOG.isDebugEnabled()) {
    LOG.debug("Using striped reads; pool threads=" + num);
  }
  STRIPED_READ_THREAD_POOL = new ThreadPoolExecutor(1, num, 60,
      TimeUnit.SECONDS, new SynchronousQueue<Runnable>(),
      new Daemon.DaemonFactory() {
    private final AtomicInteger threadIndex = new AtomicInteger(0);

    @Override
    public Thread newThread(Runnable r) {
      Thread t = super.newThread(r);
      t.setName("stripedRead-" + threadIndex.getAndIncrement());
      return t;
    }
  }, new ThreadPoolExecutor.CallerRunsPolicy() {
    @Override
    public void rejectedExecution(Runnable runnable, ThreadPoolExecutor e) {
      LOG.info("Execution for striped reading rejected, "
          + "Executing in current thread");
      // will run in the current thread
      super.rejectedExecution(runnable, e);
    }
  });
  STRIPED_READ_THREAD_POOL.allowCoreThreadTimeOut(true);
}
 

import org.apache.hadoop.util.Daemon; //导入方法依赖的package包/类
private void initializeStripedBlkRecoveryThreadPool(int num) {
  if (LOG.isDebugEnabled()) {
    LOG.debug("Using striped block recovery; pool threads=" + num);
  }
  STRIPED_BLK_RECOVERY_THREAD_POOL = new ThreadPoolExecutor(2, num, 60,
      TimeUnit.SECONDS, new LinkedBlockingQueue<Runnable>(),
      new Daemon.DaemonFactory() {
        private final AtomicInteger threadIdx = new AtomicInteger(0);

        @Override
        public Thread newThread(Runnable r) {
          Thread t = super.newThread(r);
          t.setName("stripedBlockRecovery-" + threadIdx.getAndIncrement());
          return t;
        }
      });
  STRIPED_BLK_RECOVERY_THREAD_POOL.allowCoreThreadTimeOut(true);
}
 

import org.apache.hadoop.util.Daemon; //导入方法依赖的package包/类
DirectoryScanner(DataNode dn, FSDataset dataset, Configuration conf) {
  this.datanode = dn;
  this.dataset = dataset;
  int interval = conf.getInt(DFS_DATANODE_DIRECTORYSCAN_INTERVAL_KEY,
      DFS_DATANODE_DIRECTORYSCAN_INTERVAL_DEFAULT);
  scanPeriodMsecs = interval * 1000L; // msec
  int numThreads = conf.getInt(DFS_DATANODE_DIRECTORYSCAN_THREADS_KEY,
      DFS_DATANODE_DIRECTORYSCAN_THREADS_DEFAULT);

  reportCompileThreadPool = Executors.newFixedThreadPool(numThreads,
      new Daemon.DaemonFactory());
  threadPoolExecutor = new ScheduledThreadPoolExecutor(1,
      new Daemon.DaemonFactory());
  this.delta = new FSDatasetDelta();

  this.dataset.setDatasetDelta(delta);
}
 

import org.apache.hadoop.util.Daemon; //导入方法依赖的package包/类
DirectoryScanner(DataNode datanode, FsDatasetSpi<?> dataset, Configuration conf) {
  this.datanode = datanode;
  this.dataset = dataset;
  int interval = conf.getInt(DFSConfigKeys.DFS_DATANODE_DIRECTORYSCAN_INTERVAL_KEY,
      DFSConfigKeys.DFS_DATANODE_DIRECTORYSCAN_INTERVAL_DEFAULT);
  scanPeriodMsecs = interval * 1000L; //msec
  int threads = 
      conf.getInt(DFSConfigKeys.DFS_DATANODE_DIRECTORYSCAN_THREADS_KEY,
                  DFSConfigKeys.DFS_DATANODE_DIRECTORYSCAN_THREADS_DEFAULT);

  reportCompileThreadPool = Executors.newFixedThreadPool(threads, 
      new Daemon.DaemonFactory());
  masterThread = new ScheduledThreadPoolExecutor(1,
      new Daemon.DaemonFactory());
}
 

import org.apache.hadoop.util.Daemon; //导入方法依赖的package包/类
/**
 * Create hedged reads thread pool, HEDGED_READ_THREAD_POOL, if
 * it does not already exist.
 * @param num Number of threads for hedged reads thread pool.
 * If zero, skip hedged reads thread pool creation.
 */
private synchronized void initThreadsNumForHedgedReads(int num) {
  if (num <= 0 || HEDGED_READ_THREAD_POOL != null) return;
  HEDGED_READ_THREAD_POOL = new ThreadPoolExecutor(1, num, 60,
      TimeUnit.SECONDS, new SynchronousQueue<Runnable>(),
      new Daemon.DaemonFactory() {
        private final AtomicInteger threadIndex = new AtomicInteger(0);
        @Override
        public Thread newThread(Runnable r) {
          Thread t = super.newThread(r);
          t.setName("hedgedRead-" + threadIndex.getAndIncrement());
          return t;
        }
      },
      new ThreadPoolExecutor.CallerRunsPolicy() {
        @Override
        public void rejectedExecution(Runnable runnable,
            ThreadPoolExecutor e) {
          LOG.info("Execution rejected, Executing in current thread");
          HEDGED_READ_METRIC.incHedgedReadOpsInCurThread();
          // will run in the current thread
          super.rejectedExecution(runnable, e);
        }
      });
  HEDGED_READ_THREAD_POOL.allowCoreThreadTimeOut(true);
  LOG.debug("Using hedged reads; pool threads={}", num);
}
 

import org.apache.hadoop.util.Daemon; //导入方法依赖的package包/类
/**
 * Create hedged reads thread pool, HEDGED_READ_THREAD_POOL, if
 * it does not already exist.
 * @param num Number of threads for hedged reads thread pool.
 * If zero, skip hedged reads thread pool creation.
 */
private synchronized void initThreadsNumForHedgedReads(int num) {
  if (num <= 0 || HEDGED_READ_THREAD_POOL != null) return;
  HEDGED_READ_THREAD_POOL = new ThreadPoolExecutor(1, num, 60,
      TimeUnit.SECONDS, new SynchronousQueue<Runnable>(),
      new Daemon.DaemonFactory() {
        private final AtomicInteger threadIndex =
          new AtomicInteger(0); 
        @Override
        public Thread newThread(Runnable r) {
          Thread t = super.newThread(r);
          t.setName("hedgedRead-" +
            threadIndex.getAndIncrement());
          return t;
        }
      },
      new ThreadPoolExecutor.CallerRunsPolicy() {

    @Override
    public void rejectedExecution(Runnable runnable,
        ThreadPoolExecutor e) {
      LOG.info("Execution rejected, Executing in current thread");
      HEDGED_READ_METRIC.incHedgedReadOpsInCurThread();
      // will run in the current thread
      super.rejectedExecution(runnable, e);
    }
  });
  HEDGED_READ_THREAD_POOL.allowCoreThreadTimeOut(true);
  if (LOG.isDebugEnabled()) {
    LOG.debug("Using hedged reads; pool threads=" + num);
  }
}
 

import org.apache.hadoop.util.Daemon; //导入方法依赖的package包/类
DirectoryScanner(FsDatasetSpi<?> dataset, Configuration conf) {
  this.dataset = dataset;
  int interval = conf.getInt(DFSConfigKeys.DFS_DATANODE_DIRECTORYSCAN_INTERVAL_KEY,
      DFSConfigKeys.DFS_DATANODE_DIRECTORYSCAN_INTERVAL_DEFAULT);
  scanPeriodMsecs = interval * 1000L; //msec
  int threads = 
      conf.getInt(DFSConfigKeys.DFS_DATANODE_DIRECTORYSCAN_THREADS_KEY,
                  DFSConfigKeys.DFS_DATANODE_DIRECTORYSCAN_THREADS_DEFAULT);

  reportCompileThreadPool = Executors.newFixedThreadPool(threads, 
      new Daemon.DaemonFactory());
  masterThread = new ScheduledThreadPoolExecutor(1,
      new Daemon.DaemonFactory());
}
 

import org.apache.hadoop.util.Daemon; //导入方法依赖的package包/类
DirectoryScanner(FsDatasetSpi<?> dataset, Configuration conf) {
  this.dataset = dataset;
  int interval =
      conf.getInt(DFSConfigKeys.DFS_DATANODE_DIRECTORYSCAN_INTERVAL_KEY,
          DFSConfigKeys.DFS_DATANODE_DIRECTORYSCAN_INTERVAL_DEFAULT);
  scanPeriodMsecs = interval * 1000L; //msec
  int threads =
      conf.getInt(DFSConfigKeys.DFS_DATANODE_DIRECTORYSCAN_THREADS_KEY,
          DFSConfigKeys.DFS_DATANODE_DIRECTORYSCAN_THREADS_DEFAULT);

  reportCompileThreadPool =
      Executors.newFixedThreadPool(threads, new Daemon.DaemonFactory());
  masterThread =
      new ScheduledThreadPoolExecutor(1, new Daemon.DaemonFactory());
}
 

import org.apache.hadoop.util.Daemon; //导入方法依赖的package包/类
/**
 * Create a new directory scanner, but don't cycle it running yet.
 *
 * @param datanode the parent datanode
 * @param dataset the dataset to scan
 * @param conf the Configuration object
 */
DirectoryScanner(DataNode datanode, FsDatasetSpi<?> dataset, Configuration conf) {
  this.datanode = datanode;
  this.dataset = dataset;
  int interval = conf.getInt(DFSConfigKeys.DFS_DATANODE_DIRECTORYSCAN_INTERVAL_KEY,
      DFSConfigKeys.DFS_DATANODE_DIRECTORYSCAN_INTERVAL_DEFAULT);
  scanPeriodMsecs = interval * MILLIS_PER_SECOND; //msec

  int throttle =
      conf.getInt(
        DFSConfigKeys.DFS_DATANODE_DIRECTORYSCAN_THROTTLE_LIMIT_MS_PER_SEC_KEY,
        DFSConfigKeys.DFS_DATANODE_DIRECTORYSCAN_THROTTLE_LIMIT_MS_PER_SEC_DEFAULT);

  if ((throttle > MILLIS_PER_SECOND) || (throttle <= 0)) {
    if (throttle > MILLIS_PER_SECOND) {
      LOG.error(
          DFSConfigKeys.DFS_DATANODE_DIRECTORYSCAN_THROTTLE_LIMIT_MS_PER_SEC_KEY
          + " set to value above 1000 ms/sec. Assuming default value of " +
          DFSConfigKeys.DFS_DATANODE_DIRECTORYSCAN_THROTTLE_LIMIT_MS_PER_SEC_DEFAULT);
    } else {
      LOG.error(
          DFSConfigKeys.DFS_DATANODE_DIRECTORYSCAN_THROTTLE_LIMIT_MS_PER_SEC_KEY
          + " set to value below 1 ms/sec. Assuming default value of " +
          DFSConfigKeys.DFS_DATANODE_DIRECTORYSCAN_THROTTLE_LIMIT_MS_PER_SEC_DEFAULT);
    }

    throttleLimitMsPerSec =
        DFSConfigKeys.DFS_DATANODE_DIRECTORYSCAN_THROTTLE_LIMIT_MS_PER_SEC_DEFAULT;
  } else {
    throttleLimitMsPerSec = throttle;
  }

  int threads = 
      conf.getInt(DFSConfigKeys.DFS_DATANODE_DIRECTORYSCAN_THREADS_KEY,
                  DFSConfigKeys.DFS_DATANODE_DIRECTORYSCAN_THREADS_DEFAULT);

  reportCompileThreadPool = Executors.newFixedThreadPool(threads, 
      new Daemon.DaemonFactory());
  masterThread = new ScheduledThreadPoolExecutor(1,
      new Daemon.DaemonFactory());
}