Java ThreadFactoryBuilder.build方法代码示例

import com.google.common.util.concurrent.ThreadFactoryBuilder; //导入方法依赖的package包/类
public TBoundedThreadPoolServer(Args options, ThriftMetrics metrics) {
  super(options);

  if (options.maxQueuedRequests > 0) {
    this.callQueue = new CallQueue(
        new LinkedBlockingQueue<Call>(options.maxQueuedRequests), metrics);
  } else {
    this.callQueue = new CallQueue(new SynchronousQueue<Call>(), metrics);
  }

  ThreadFactoryBuilder tfb = new ThreadFactoryBuilder();
  tfb.setDaemon(true);
  tfb.setNameFormat("thrift-worker-%d");
  executorService =
      new ThreadPoolExecutor(options.minWorkerThreads,
          options.maxWorkerThreads, options.threadKeepAliveTimeSec,
          TimeUnit.SECONDS, this.callQueue, tfb.build());
  serverOptions = options;
}
 

import com.google.common.util.concurrent.ThreadFactoryBuilder; //导入方法依赖的package包/类
public SimpleThreadFactory(String name) {
    ThreadFactoryBuilder builder = new ThreadFactoryBuilder();
    builder
        .setNameFormat(name)
        .setUncaughtExceptionHandler((t, e) -> logger.error("Uncaught exception of thread_" + t.toString(), e));
    this.threadFactory = builder.build();
}
 

import com.google.common.util.concurrent.ThreadFactoryBuilder; //导入方法依赖的package包/类
private static ExecutorService createExecutor(
    int workerThreads, ThriftMetrics metrics) {
  CallQueue callQueue = new CallQueue(
      new LinkedBlockingQueue<Call>(), metrics);
  ThreadFactoryBuilder tfb = new ThreadFactoryBuilder();
  tfb.setDaemon(true);
  tfb.setNameFormat("thrift2-worker-%d");
  ThreadPoolExecutor pool = new ThreadPoolExecutor(workerThreads, workerThreads,
          Long.MAX_VALUE, TimeUnit.SECONDS, callQueue, tfb.build());
  pool.prestartAllCoreThreads();
  return pool;
}
 

import com.google.common.util.concurrent.ThreadFactoryBuilder; //导入方法依赖的package包/类
ExecutorService createExecutor(BlockingQueue<Runnable> callQueue,
                               int minWorkers, int maxWorkers) {
  ThreadFactoryBuilder tfb = new ThreadFactoryBuilder();
  tfb.setDaemon(true);
  tfb.setNameFormat("thrift-worker-%d");
  return new ThreadPoolExecutor(minWorkers, maxWorkers,
          Long.MAX_VALUE, TimeUnit.SECONDS, callQueue, tfb.build());
}
 

import com.google.common.util.concurrent.ThreadFactoryBuilder; //导入方法依赖的package包/类
@Override
protected void serviceStart() throws Exception {
  ThreadFactoryBuilder tfBuilder = new ThreadFactoryBuilder()
      .setNameFormat("CommitterEvent Processor #%d");
  if (jobClassLoader != null) {
    // if the job classloader is enabled, we need to use the job classloader
    // as the thread context classloader (TCCL) of these threads in case the
    // committer needs to load another class via TCCL
    ThreadFactory backingTf = new ThreadFactory() {
      @Override
      public Thread newThread(Runnable r) {
        Thread thread = new Thread(r);
        thread.setContextClassLoader(jobClassLoader);
        return thread;
      }
    };
    tfBuilder.setThreadFactory(backingTf);
  }
  ThreadFactory tf = tfBuilder.build();
  launcherPool = new ThreadPoolExecutor(5, 5, 1,
      TimeUnit.HOURS, new LinkedBlockingQueue<Runnable>(), tf);
  eventHandlingThread = new Thread(new Runnable() {
    @Override
    public void run() {
      CommitterEvent event = null;
      while (!stopped.get() && !Thread.currentThread().isInterrupted()) {
        try {
          event = eventQueue.take();
        } catch (InterruptedException e) {
          if (!stopped.get()) {
            LOG.error("Returning, interrupted : " + e);
          }
          return;
        }
        // the events from the queue are handled in parallel
        // using a thread pool
        launcherPool.execute(new EventProcessor(event));        }
    }
  });
  eventHandlingThread.setName("CommitterEvent Handler");
  eventHandlingThread.start();
  super.serviceStart();
}