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.
Returns:
this for the builder pattern
 
   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