Java ThreadFactory类代码示例

import java.util.concurrent.ThreadFactory; //导入依赖的package包/类
public static Channel openChannel ( InetSocketAddress isa ) throws IOException, SocketException {
    System.err.println("* Opening socket " + isa);
    Socket s = SocketFactory.getDefault().createSocket(isa.getAddress(), isa.getPort());
    s.setKeepAlive(true);
    s.setTcpNoDelay(true);

    System.err.println("* Opening channel");
    OutputStream outputStream = s.getOutputStream();
    DataOutputStream dos = new DataOutputStream(outputStream);
    dos.writeUTF("Protocol:CLI-connect");
    ExecutorService cp = Executors.newCachedThreadPool(new ThreadFactory() {

        public Thread newThread ( Runnable r ) {
            Thread t = new Thread(r, "Channel");
            t.setDaemon(true);
            return t;
        }
    });
    Channel c = new ChannelBuilder("EXPLOIT", cp).withMode(Mode.BINARY).build(s.getInputStream(), outputStream);
    System.err.println("* Channel open");
    return c;
}
 

import java.util.concurrent.ThreadFactory; //导入依赖的package包/类
private static ExecutorService getExecutor() {
    synchronized (sExecutorServiceLock) {
        if (sExecutorService == null) {
            ThreadFactory threadFactory = new ThreadFactory() {
                private final AtomicInteger mCount = new AtomicInteger(1);

                    @Override
                public Thread newThread(Runnable r) {
                    Thread thread = new Thread(r,
                            "HttpUrlConnection #"
                            + mCount.getAndIncrement());
                    // Note that this thread is not doing actual networking.
                    // It's only a controller.
                    thread.setPriority(Thread.NORM_PRIORITY);
                    return thread;
                }
            };
            sExecutorService = Executors.newCachedThreadPool(threadFactory);
        }
        return sExecutorService;
    }
}
 

import java.util.concurrent.ThreadFactory; //导入依赖的package包/类
private void scheduleClockUpdating() {
    ScheduledExecutorService scheduler = Executors.newSingleThreadScheduledExecutor(new ThreadFactory() {
        @Override
        public Thread newThread(Runnable runnable) {
            Thread thread = new Thread(runnable, "System Clock");
            thread.setDaemon(true);
            return thread;
        }
    });
    scheduler.scheduleAtFixedRate(new Runnable() {
        @Override
        public void run() {
            now.set(System.currentTimeMillis());
        }
    }, precision, precision, TimeUnit.MILLISECONDS);
}
 

import java.util.concurrent.ThreadFactory; //导入依赖的package包/类
@Override
public void afterPropertiesSet() throws NamingException {
	if (this.jndiName != null) {
		try {
			this.threadFactory = this.jndiLocator.lookup(this.jndiName, ThreadFactory.class);
		}
		catch (NamingException ex) {
			if (logger.isDebugEnabled()) {
				logger.debug("Failed to find [java:comp/DefaultManagedThreadFactory] in JNDI", ex);
			}
			if (logger.isInfoEnabled()) {
				logger.info("Could not find default managed thread factory in JNDI - " +
						"proceeding with default local thread factory");
			}
		}
	}
}
 

import java.util.concurrent.ThreadFactory; //导入依赖的package包/类
private static PooledExecutorWithDMStats createExecutor(PoolStatHelper poolHelper,
    final ThreadGroup threadGroup) {
  ThreadFactory factory = new ThreadFactory() {
    private final AtomicInteger threadNum = new AtomicInteger();

    public Thread newThread(Runnable r) {
      Thread thread = new Thread(threadGroup, r,
          "locator request thread[" + threadNum.incrementAndGet() + "]");
      thread.setDaemon(true);
      return thread;
    }
  };

  return new PooledExecutorWithDMStats(new SynchronousQueue(), MAX_POOL_SIZE, poolHelper, factory,
      POOL_IDLE_TIMEOUT, new ThreadPoolExecutor.CallerRunsPolicy());
}
 

import java.util.concurrent.ThreadFactory; //导入依赖的package包/类
@Test
public void customEventLoopGroup_NotClosedWhenClientIsClosed() throws Exception {

    ThreadFactory threadFactory = spy(new CustomThreadFactory());
    // Cannot use DefaultEventLoopGroupFactory because the concrete
    // implementation it creates is platform-dependent and could be a final
    // (i.e. non-spyable) class.
    EventLoopGroup eventLoopGroup = spy(new NioEventLoopGroup(0, threadFactory));
    EventLoopGroupConfiguration eventLoopGroupConfiguration =
            EventLoopGroupConfiguration.builder()
                                       .eventLoopGroup(eventLoopGroup)
                                       .build();
    SdkAsyncHttpClient customClient =
            NettySdkHttpClientFactory.builder()
                                     .trustAllCertificates(true)
                                     .eventLoopGroupConfiguration(eventLoopGroupConfiguration)
                                     .build()
                                     .createHttpClient();

    makeSimpleRequest(customClient);
    customClient.close();

    Mockito.verify(threadFactory, atLeastOnce()).newThread(Mockito.any());
    Mockito.verify(eventLoopGroup, never()).shutdownGracefully();
}
 

import java.util.concurrent.ThreadFactory; //导入依赖的package包/类
public DatadogMeterRegistry(DatadogConfig config, Clock clock, ThreadFactory threadFactory) {
    super(config, clock);

    this.config().namingConvention(new DatadogNamingConvention());

    try {
        this.postTimeSeriesEndpoint = URI.create(config.uri() + "/api/v1/series?api_key=" + config.apiKey()).toURL();
    } catch (MalformedURLException e) {
        // not possible
        throw new RuntimeException(e);
    }

    this.config = config;

    start(threadFactory);
}
 

import java.util.concurrent.ThreadFactory; //导入依赖的package包/类
@Override
protected void serviceInit(Configuration conf) throws Exception {
  ThreadFactory tf = new ThreadFactoryBuilder()
    .setNameFormat("DeletionService #%d")
    .build();
  if (conf != null) {
    sched = new DelServiceSchedThreadPoolExecutor(
        conf.getInt(YarnConfiguration.NM_DELETE_THREAD_COUNT,
        YarnConfiguration.DEFAULT_NM_DELETE_THREAD_COUNT), tf);
    debugDelay = conf.getInt(YarnConfiguration.DEBUG_NM_DELETE_DELAY_SEC, 0);
  } else {
    sched = new DelServiceSchedThreadPoolExecutor(
        YarnConfiguration.DEFAULT_NM_DELETE_THREAD_COUNT, tf);
  }
  sched.setExecuteExistingDelayedTasksAfterShutdownPolicy(false);
  sched.setKeepAliveTime(60L, SECONDS);
  if (stateStore.canRecover()) {
    recover(stateStore.loadDeletionServiceState());
  }
  super.serviceInit(conf);
}
 

import java.util.concurrent.ThreadFactory; //导入依赖的package包/类
/**
 * Конструктор для тестирования
 *
 * @param queueRegistry                  хранилище очередей
 * @param defaultTaskLifecycleListener   слушатель жизненного цикла задачи
 * @param defaultThreadLifecycleListener слушатель жизненного цикла потока очереди
 * @param threadFactoryProvider          фабрика фабрик создания потоков
 * @param queueThreadPoolFactory         фабрика для создания пула обработки очередей
 * @param queueLoopFactory               фабрика для создания {@link QueueLoop}
 * @param queueRunnerFactory             фабрика для создания {@link QueueRunner}
 */
QueueExecutionPool(@Nonnull QueueRegistry queueRegistry,
                   @Nonnull TaskLifecycleListener defaultTaskLifecycleListener,
                   @Nonnull ThreadLifecycleListener defaultThreadLifecycleListener,
                   @Nonnull BiFunction<QueueLocation, QueueShardId, ThreadFactory> threadFactoryProvider,
                   @Nonnull BiFunction<Integer, ThreadFactory, ExecutorService> queueThreadPoolFactory,
                   @Nonnull Function<ThreadLifecycleListener, QueueLoop> queueLoopFactory,
                   @Nonnull Function<ShardPoolInstance, QueueRunner> queueRunnerFactory) {
    this.queueRegistry = Objects.requireNonNull(queueRegistry);
    this.defaultTaskLifecycleListener = Objects.requireNonNull(defaultTaskLifecycleListener);
    this.defaultThreadLifecycleListener = Objects.requireNonNull(defaultThreadLifecycleListener);
    this.queueThreadPoolFactory = Objects.requireNonNull(queueThreadPoolFactory);
    this.threadFactoryProvider = Objects.requireNonNull(threadFactoryProvider);
    this.queueLoopFactory = Objects.requireNonNull(queueLoopFactory);
    this.queueRunnerFactory = Objects.requireNonNull(queueRunnerFactory);
}
 

import java.util.concurrent.ThreadFactory; //导入依赖的package包/类
public ServiceCacheImplProxy(ServiceDiscoveryImpl<T> discovery, String name, ThreadFactory threadFactory) {
    this.serviceCacheImpl = new ServiceCacheImpl<T>(discovery, name, threadFactory);

    try {
        Field privateListenerContainerField = ServiceCacheImpl.class.getDeclaredField("listenerContainer");
        privateListenerContainerField.setAccessible(true);
        this.listenerContainer = (ListenerContainer)privateListenerContainerField.get(serviceCacheImpl);
    } catch (NoSuchFieldException | IllegalAccessException e) {
        log.error("Failed to construct Service Cache. Container listeners is null.");
    }

    Preconditions.checkNotNull(discovery, "discovery cannot be null");
    Preconditions.checkNotNull(name, "name cannot be null");
    Preconditions.checkNotNull(threadFactory, "threadFactory cannot be null");
    Preconditions.checkNotNull(this.listenerContainer, "container of listeners can not be null");


    this.discovery = discovery;
    this.cache = new PathChildrenCache(discovery.getClient(), discovery.pathForName(name), true, threadFactory);
    this.cache.getListenable().addListener(this);
}
 

import java.util.concurrent.ThreadFactory; //导入依赖的package包/类
/**
 * Create a new server listener.
 * @param serverConnector connector
 * @param socketFactory socket factory
 * @param authenticator authenticator
 * @param accessController access controller
 * @param threadPriority  thread priority
 * @throws IOException if an I/O error occurs when constructing the server listener
 */
ServerListener(final ServerConnector serverConnector, final JMXSocketFactory socketFactory, final JMXAuthenticator authenticator,
               final JMXAccessController accessController, final int threadPriority) throws IOException {
    this.serverConnector = serverConnector;
    this.authenticator = authenticator;
    this.accessController = accessController;
    serverId = SERVER_ID.getAndIncrement();

    // Setup executor service
    final ThreadFactory threadFactory = new ConnectionThreadFactory(serverId, threadPriority);
    executorService = Executors.newCachedThreadPool(threadFactory);

    // Setup server socket
    serverSocket = socketFactory.createServerSocket(serverConnector.getAddress());
    serverConnector.updateAddress(serverSocket.getLocalPort());
    serverSocket.setSoTimeout(0);
}
 

import java.util.concurrent.ThreadFactory; //导入依赖的package包/类
/**
 * @deprecated This method is only used from configuration modules and thus callers of it
 *             should use service injection to make the executor configurable.
 */
@Deprecated
public static synchronized ListeningExecutorService getDefaultCommitExecutor() {
    if (COMMIT_EXECUTOR == null) {
        final ThreadFactory factory = new ThreadFactoryBuilder().setDaemon(true).setNameFormat("md-sal-binding-commit-%d").build();
        /*
         * FIXME: this used to be newCacheThreadPool(), but MD-SAL does not have transaction
         *        ordering guarantees, which means that using a concurrent threadpool results
         *        in application data being committed in random order, potentially resulting
         *        in inconsistent data being present. Once proper primitives are introduced,
         *        concurrency can be reintroduced.
         */
        final ExecutorService executor = Executors.newSingleThreadExecutor(factory);
        COMMIT_EXECUTOR = MoreExecutors.listeningDecorator(executor);
    }

    return COMMIT_EXECUTOR;
}
 

import java.util.concurrent.ThreadFactory; //导入依赖的package包/类
CustomTPE(int corePoolSize,
          int maximumPoolSize,
          long keepAliveTime,
          TimeUnit unit,
          BlockingQueue<Runnable> workQueue,
          ThreadFactory threadFactory,
          RejectedExecutionHandler handler) {
    super(corePoolSize, maximumPoolSize, keepAliveTime, unit,
      workQueue, threadFactory, handler);
}
 

import java.util.concurrent.ThreadFactory; //导入依赖的package包/类
public DebuggableThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, ThreadFactory threadFactory)
{
    super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, threadFactory);
    allowCoreThreadTimeOut(true);

    // block task submissions until queue has room.
    // this is fighting TPE's design a bit because TPE rejects if queue.offer reports a full queue.
    // we'll just override this with a handler that retries until it gets in.  ugly, but effective.
    // (there is an extensive analysis of the options here at
    //  http://today.java.net/pub/a/today/2008/10/23/creating-a-notifying-blocking-thread-pool-executor.html)
    this.setRejectedExecutionHandler(blockingExecutionHandler);
}
 

import java.util.concurrent.ThreadFactory; //导入依赖的package包/类
private static ThreadFactory getThreadFactory(final String name) {
    return new ThreadFactory() {
        private int threadCount = 1;

        public Thread newThread(Runnable r) {
            Thread thread = new Thread(r);
            if (name != null) {
                thread.setName(name + "-" + threadCount++);
            }
            thread.setPriority(Thread.MAX_PRIORITY);
            return thread;
        }
    };
}