Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Copyright (C) 2010 The Guava Authors
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 
 package com.google.common.util.concurrent;
 
 import static com.google.common.base.Preconditions.checkArgument;
 import static com.google.common.base.Preconditions.checkNotNull;
 
A ThreadFactory builder, providing any combination of these features:
  • whether threads should be marked as daemon threads
  • a naming format
  • a thread priority
  • an uncaught exception handler
  • a backing thread factory
If no backing thread factory is provided, a default backing thread factory is used as if by calling setThreadFactory(java.util.concurrent.Executors.defaultThreadFactory()).

Author(s):
Kurt Alfred Kluever
Since:
4.0
 
 public final class ThreadFactoryBuilder {
   private String nameFormat = null;
   private Boolean daemon = null;
   private Integer priority = null;
   private ThreadFactory backingThreadFactory = null;

  
Creates a new java.util.concurrent.ThreadFactory builder.
 
   public ThreadFactoryBuilder() {}

  
Sets the naming format to use when naming threads (java.lang.Thread.setName(java.lang.String)) which are created with this ThreadFactory.

Parameters:
nameFormat a java.lang.String.format(java.lang.String,java.lang.Object[])-compatible format String, to which a unique integer (0, 1, etc.) will be supplied as the single parameter. This integer will be unique to the built instance of the ThreadFactory and will be assigned sequentially. For example, "rpc-pool-%d" will generate thread names like "rpc-pool-0", "rpc-pool-1", "rpc-pool-2", etc.
Returns:
this for the builder pattern
 
   @SuppressWarnings("ReturnValueIgnored")
   public ThreadFactoryBuilder setNameFormat(String nameFormat) {
     String.format(nameFormat, 0); // fail fast if the format is bad or null
     this. = nameFormat;
     return this;
   }

  
Sets daemon or not for new threads created with this ThreadFactory.

Parameters:
daemon whether or not new Threads created with this ThreadFactory will be daemon threads
Returns:
this for the builder pattern
 
   public ThreadFactoryBuilder setDaemon(boolean daemon) {
     this. = daemon;
     return this;
   }

  
Sets the priority for new threads created with this ThreadFactory.

Parameters:
priority the priority for new Threads created with this ThreadFactory
Returns:
this for the builder pattern
 
   public ThreadFactoryBuilder setPriority(int priority) {
     // Thread#setPriority() already checks for validity. These error messages
     // are nicer though and will fail-fast.
     checkArgument(priority >= .,
         "Thread priority (%s) must be >= %s"priority.);
    checkArgument(priority <= .,
        "Thread priority (%s) must be <= %s"priority.);
    this. = priority;
    return this;
  }

  
Sets the java.lang.Thread.UncaughtExceptionHandler for new threads created with this ThreadFactory.

Parameters:
uncaughtExceptionHandler the uncaught exception handler for new Threads created with this ThreadFactory
Returns:
this for the builder pattern
      UncaughtExceptionHandler uncaughtExceptionHandler) {
    this. = checkNotNull(uncaughtExceptionHandler);
    return this;
  }

  
Sets the backing java.util.concurrent.ThreadFactory for new threads created with this ThreadFactory. Threads will be created by invoking #newThread(Runnable) on this backing java.util.concurrent.ThreadFactory.

Parameters:
backingThreadFactory the backing java.util.concurrent.ThreadFactory which will be delegated to during thread creation.
Returns:
this for the builder pattern
See also:
MoreExecutors
      ThreadFactory backingThreadFactory) {
    this. = checkNotNull(backingThreadFactory);
    return this;
  }

  
Returns a new thread factory using the options supplied during the building process. After building, it is still possible to change the options used to build the ThreadFactory and/or build again. State is not shared amongst built instances.

Returns:
the fully constructed java.util.concurrent.ThreadFactory
  public ThreadFactory build() {
    return build(this);
  }
  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(String.format(nameFormatcount.getAndIncrement()));
        }
        if (daemon != null) {
          thread.setDaemon(daemon);
        }
        if (priority != null) {
          thread.setPriority(priority);
        }
        if (uncaughtExceptionHandler != null) {
          thread.setUncaughtExceptionHandler(uncaughtExceptionHandler);
        }
        return thread;
      }
    };
  }
New to GrepCode? Check out our FAQ X