Java Code Examples for java.util.concurrent.ThreadFactory#newThread()

/**
 * Starts the Cleaner implementation.
 * Ensure this is the CleanerImpl for the Cleaner.
 * When started waits for Cleanables to be queued.
 * @param cleaner the cleaner
 * @param threadFactory the thread factory
 */
public void start(Cleaner cleaner, ThreadFactory threadFactory) {
    if (getCleanerImpl(cleaner) != this) {
        throw new AssertionError("wrong cleaner");
    }
    // schedule a nop cleaning action for the cleaner, so the associated thread
    // will continue to run at least until the cleaner is reclaimable.
    new CleanerCleanable(cleaner);

    if (threadFactory == null) {
        threadFactory = CleanerImpl.InnocuousThreadFactory.factory();
    }

    // now that there's at least one cleaning action, for the cleaner,
    // we can start the associated thread, which runs until
    // all cleaning actions have been run.
    Thread thread = threadFactory.newThread(this);
    thread.setDaemon(true);
    thread.start();
}
 

/**
 * Get a named {@link ThreadFactory} that just builds daemon threads.
 * @param prefix name prefix for all threads created from the factory
 * @return a thread factory that creates named, daemon threads with
 *         the supplied exception handler and normal priority
 */
private static ThreadFactory newDaemonThreadFactory(final String prefix) {
  final ThreadFactory namedFactory = getNamedThreadFactory(prefix);
  return new ThreadFactory() {
    @Override
    public Thread newThread(Runnable r) {
      Thread t = namedFactory.newThread(r);
      if (!t.isDaemon()) {
        t.setDaemon(true);
      }
      if (t.getPriority() != Thread.NORM_PRIORITY) {
        t.setPriority(Thread.NORM_PRIORITY);
      }
      return t;
    }

  };
}
 

/**
 * Starts the Cleaner implementation.
 * Ensure this is the CleanerImpl for the Cleaner.
 * When started waits for Cleanables to be queued.
 * @param cleaner the cleaner
 * @param threadFactory the thread factory
 */
public void start(Cleaner cleaner, ThreadFactory threadFactory) {
    if (getCleanerImpl(cleaner) != this) {
        throw new AssertionError("wrong cleaner");
    }
    // schedule a nop cleaning action for the cleaner, so the associated thread
    // will continue to run at least until the cleaner is reclaimable.
    new CleanerCleanable(cleaner);

    if (threadFactory == null) {
        threadFactory = CleanerImpl.InnocuousThreadFactory.factory();
    }

    // now that there's at least one cleaning action, for the cleaner,
    // we can start the associated thread, which runs until
    // all cleaning actions have been run.
    Thread thread = threadFactory.newThread(this);
    thread.setDaemon(true);
    thread.start();
}
 

protected ThreadFactory makeContextual(ThreadFactory origin, 
                                       ClassLoader contextClassLoader, 
                                       Function<? super Runnable, ? extends Runnable> wrapper) {
    
    if (null == contextClassLoader) {
        return origin;
    } else {
        SecurityManager sm = System.getSecurityManager();
        if (sm != null) {
            // Fail fast
            sm.checkPermission(new RuntimePermission("setContextClassLoader"));
        }
        return r -> {
            Runnable contextualRunnable = () -> {
                Thread.currentThread().setContextClassLoader(contextClassLoader);
                 r.run();
            };
            return origin.newThread(wrapper.apply(contextualRunnable)); 
        };
    }
}
 

public ThreadPoolEventTarget(
    final ThreadFactory wrappedFactory, final ThreadInitializer threadInitializer) {
  int poolSize = 1;
  BlockingQueue<Runnable> queue = new LinkedBlockingQueue<Runnable>();

  executor =
      new ThreadPoolExecutor(
          poolSize,
          poolSize,
          3,
          TimeUnit.SECONDS,
          queue,
          new ThreadFactory() {

            @Override
            public Thread newThread(Runnable r) {
              Thread thread = wrappedFactory.newThread(r);
              threadInitializer.setName(thread, "FirebaseDatabaseEventTarget");
              threadInitializer.setDaemon(thread, true);
              // TODO: should we set an uncaught exception handler here? Probably want to let
              // exceptions happen...
              return thread;
            }
          });
}
 

protected ThreadFactory makeConfigured(ThreadFactory origin, 
                                       Boolean isDaemon, 
                                       Integer priority, 
                                       UncaughtExceptionHandler uncaughtExceptionHandler) {
    
    if (null != isDaemon && null == priority && null == uncaughtExceptionHandler) {
        return origin;
    } else {
        return r -> {
          Thread t = origin.newThread(r);
          if (null != priority && priority != t.getPriority()) {
              t.setPriority(priority);
          }
          if (null != isDaemon && isDaemon != t.isDaemon()) {
              t.setDaemon(isDaemon);
          }
          if (null != uncaughtExceptionHandler) {
              t.setUncaughtExceptionHandler(uncaughtExceptionHandler);
          }
          return t;
        };
    }
}
 

@Test
public void buildThreadFactory() {

	Runnable testRunnable = new Runnable() {
		@Override
		public void run() {
		}
	};
	// 测试name格式
	ThreadFactory threadFactory = ThreadPoolUtil.buildThreadFactory("example");
	Thread thread = threadFactory.newThread(testRunnable);

	assertThat(thread.getName()).isEqualTo("example-0");
	assertThat(thread.isDaemon()).isFalse();

	// 测试daemon属性设置
	threadFactory = ThreadPoolUtil.buildThreadFactory("example", true);
	Thread thread2 = threadFactory.newThread(testRunnable);

	assertThat(thread.getName()).isEqualTo("example-0");
	assertThat(thread2.isDaemon()).isTrue();
}
 

static ThreadFactory createQpidByteBufferTrackingThreadFactory(ThreadFactory factory)
{
    return r -> factory.newThread(() -> {
        try
        {
            r.run();
        }
        finally
        {
            final SingleQpidByteBuffer cachedThreadLocalBuffer = _cachedBuffer.get();
            if (cachedThreadLocalBuffer != null)
            {
                cachedThreadLocalBuffer.dispose();
                _cachedBuffer.remove();
            }
        }
    });
}
 

MessageBatcher(
    int bufferSize,
    int maxBatchSize,
    EnqueueBehaviour enqueueBehaviour,
    Function<List<MESSAGE>, List<RESPONSE>> batchHandler,
    ThreadFactory threadFactory) {
  if (bufferSize < maxBatchSize) {
    throw new IllegalArgumentException("maxBatchSize must be less than or equal to bufferSize");
  }
  this.queue = new LinkedBlockingQueue<>(bufferSize);
  this.maxBatchSize = maxBatchSize;
  this.batchHandler = batchHandler;
  this.enqueueBehaviour = enqueueBehaviour;

  thread = threadFactory.newThread(this::processMessages);
  thread.start();
}
 

@Test
public void buildThreadFactory() {

	Runnable testRunnable = new Runnable() {
		@Override
		public void run() {
		}
	};
	// 测试name格式
	ThreadFactory threadFactory = ThreadPoolUtil.buildThreadFactory("example");
	Thread thread = threadFactory.newThread(testRunnable);

	assertThat(thread.getName()).isEqualTo("example-0");
	assertThat(thread.isDaemon()).isFalse();

	// 测试daemon属性设置
	threadFactory = ThreadPoolUtil.buildThreadFactory("example", true);
	Thread thread2 = threadFactory.newThread(testRunnable);

	assertThat(thread.getName()).isEqualTo("example-0");
	assertThat(thread2.isDaemon()).isTrue();
}
 

static void threadFactory() {
    ThreadFactory factory = new ThreadFactory() {
        int count = 0;

        @Override
        public Thread newThread(Runnable r) {
            count ++;
            return new Thread(r, "Thread-" + count);
        }
    };

    Runnable runnable = new Runnable() {
        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName() + " started!");
        }
    };

    Thread thread = factory.newThread(runnable);
    thread.start();
    Thread thread1 = factory.newThread(runnable);
    thread1.start();
}
 

public BulkProcessor(
    Time time,
    BulkClient<R, B> bulkClient,
    int maxBufferedRecords,
    int maxInFlightRequests,
    int batchSize,
    long lingerMs,
    int maxRetries,
    long retryBackoffMs
) {
  this.time = time;
  this.bulkClient = bulkClient;
  this.maxBufferedRecords = maxBufferedRecords;
  this.batchSize = batchSize;
  this.lingerMs = lingerMs;
  this.maxRetries = maxRetries;
  this.retryBackoffMs = retryBackoffMs;

  unsentRecords = new ArrayDeque<>(maxBufferedRecords);

  final ThreadFactory threadFactory = makeThreadFactory();
  farmer = threadFactory.newThread(farmerTask());
  executor = Executors.newFixedThreadPool(maxInFlightRequests, threadFactory);
}
 

public HashedWheelTimer(ThreadFactory threadFactory, long tickDuration, TimeUnit unit, int ticksPerWheel, Processor processor) {
    this.processor = processor;
    if (threadFactory == null) {
        throw new NullPointerException("threadFactory");
    }
    if (unit == null) {
        throw new NullPointerException("unit");
    }
    if (tickDuration <= 0) {
        throw new IllegalArgumentException("tickDuration must be greater than 0: " + tickDuration);
    }
    if (ticksPerWheel <= 0) {
        throw new IllegalArgumentException("ticksPerWheel must be greater than 0: " + ticksPerWheel);
    }

    // Normalize ticksPerWheel to power of two and initialize the wheel.
    wheel = createWheel(ticksPerWheel);
    mask = wheel.length - 1;

    // Convert tickDuration to nanos.
    this.tickDuration = unit.toNanos(tickDuration);

    // Prevent overflow.
    if (this.tickDuration >= Long.MAX_VALUE / wheel.length) {
        throw new IllegalArgumentException(String.format(
                "tickDuration: %d (expected: 0 < tickDuration in nanos < %d",
                tickDuration, Long.MAX_VALUE / wheel.length));
    }
    workerThread = threadFactory.newThread(worker);
}
 

void test(final Class<?> exceptionClass,
          final ThreadFactory failingThreadFactory)
        throws Throwable {
    ThreadFactory flakyThreadFactory = new ThreadFactory() {
        int seq = 0;
        public Thread newThread(Runnable r) {
            if (seq++ < 4)
                return new Thread(r);
            else
                return failingThreadFactory.newThread(r);
        }};
    ThreadPoolExecutor pool =
        new ThreadPoolExecutor(10, 10,
                               0L, TimeUnit.SECONDS,
                               new LinkedBlockingQueue(),
                               flakyThreadFactory);
    try {
        for (int i = 0; i < 8; i++)
            pool.submit(new Runnable() { public void run() {} });
        check(exceptionClass == null);
    } catch (Throwable t) {
        /* t.printStackTrace(); */
        check(exceptionClass.isInstance(t));
    }
    pool.shutdown();
    check(pool.awaitTermination(LONG_DELAY_MS, MILLISECONDS));
}
 

@Provides @Singleton
NamedThreadFactory namedThreadFactory(ThreadFactory factory) {
    return (name, code) -> {
        final Thread thread = factory.newThread(code);
        thread.setName(name);
        return thread;
    };
}
 

private Thread waitToExit(ThreadFactory threadFactory, final Provider<? extends SafeExit> provider) {
  return threadFactory.newThread(new Runnable() {
    @Override
    public void run() {
      SafeExit safeExit;
      try {
        safeExit = provider.get();
      } catch (Exception ex){
        // ignore since this means no instance wasn't running on this node.
        return;
      }
      safeExit.waitToExit();
    }
  });
}
 

private void verifyGetNamedThreadFactory(String threadFactorName) {
  final ThreadFactory threadFactory = ExecutorUtils.getNamedThreadFactory(threadFactorName);
  Thread thread;
  for (int i = 0; i < 2; i++) {
    thread = threadFactory.newThread(mock(Runnable.class));
    // Thread identifier starts from 1
    assertEquals(threadFactorName + (i + 1), thread.getName());
  }
}
 

public FileTailer(FileChangeListener fileChangeListener, int bufferSize, int maxLinesPerCycle, long idleTimeMs, ThreadFactory processingThreadFactory) {
    this.tailableFiles = new CopyOnWriteArrayList<>();
    this.fileChangeListener = fileChangeListener;
    this.buffer = ByteBuffer.allocate(bufferSize);
    this.maxLinesPerCycle = maxLinesPerCycle;
    this.idleTimeMs = idleTimeMs;
    this.processingThread = processingThreadFactory.newThread(this);
}
 

/**
 * Creates a new timer.
 *
 * @param threadFactory      a {@link ThreadFactory} that creates a
 *                           background {@link Thread} which is dedicated to
 *                           {@link TimerTask} execution.
 * @param tickDuration       the duration between tick
 * @param unit               the time unit of the {@code tickDuration}
 * @param ticksPerWheel      the size of the wheel
 * @param maxPendingTimeouts The maximum number of pending timeouts after which call to
 *                           {@code newTimeout} will result in
 *                           {@link RejectedExecutionException}
 *                           being thrown. No maximum pending timeouts limit is assumed if
 *                           this value is 0 or negative.
 * @throws NullPointerException     if either of {@code threadFactory} and {@code unit} is {@code null}
 * @throws IllegalArgumentException if either of {@code tickDuration} and {@code ticksPerWheel} is <= 0
 */
public HashedWheelTimer(ThreadFactory threadFactory, long tickDuration, TimeUnit unit, int ticksPerWheel,
                        long maxPendingTimeouts) {

    if (threadFactory == null) {
        throw new NullPointerException("threadFactory");
    }
    if (unit == null) {
        throw new NullPointerException("unit");
    }
    if (tickDuration <= 0) {
        throw new IllegalArgumentException("tickDuration must be greater than 0: " + tickDuration);
    }
    if (ticksPerWheel <= 0) {
        throw new IllegalArgumentException("ticksPerWheel must be greater than 0: " + ticksPerWheel);
    }

    // Normalize ticksPerWheel to power of two and initialize the wheel.
    wheel = createWheel(ticksPerWheel);
    mask = wheel.length - 1;

    // Convert tickDuration to nanos.
    this.tickDuration = unit.toNanos(tickDuration);

    // Prevent overflow.
    if (this.tickDuration >= Long.MAX_VALUE / wheel.length) {
        throw new IllegalArgumentException(String.format(
            "tickDuration: %d (expected: 0 < tickDuration in nanos < %d", tickDuration, Long.MAX_VALUE
                                                                                        / wheel.length));
    }
    workerThread = threadFactory.newThread(worker);

    this.maxPendingTimeouts = maxPendingTimeouts;

    if (instanceCounter.incrementAndGet() > INSTANCE_COUNT_LIMIT
        && warnedTooManyInstances.compareAndSet(false, true)) {
        reportTooManyInstances();
    }
}
 

private static ThreadFactory build(ThreadFactoryBuilder builder) {
        final String nameFormat = builder.nameFormat;
        final Boolean daemon = builder.daemon;
        final Integer priority = builder.priority;
        final UncaughtExceptionHandler uncaughtExceptionHandler = builder.uncaughtExceptionHandler;
        final ThreadFactory backingThreadFactory = (builder.backingThreadFactory != null) ? builder.backingThreadFactory : Executors.defaultThreadFactory();
        final AtomicLong count = (nameFormat != null) ? new AtomicLong(0) : null;
        return new ThreadFactory() {
            @Override
            public Thread newThread(Runnable runnable) {
                Thread thread = backingThreadFactory.newThread(runnable);
                if (nameFormat != null) {
                    thread.setName(format(nameFormat, count.getAndIncrement()));
                }
                if (daemon != null) {
                    thread.setDaemon(daemon);
                }
                if (priority != null) {
                    thread.setPriority(priority);
                }
                if (uncaughtExceptionHandler != null) {
                    thread.setUncaughtExceptionHandler(uncaughtExceptionHandler);
                }
                return thread;
            }
        };
    }