View Javadoc
1   /*
2    * Copyright 2013 The Netty Project
3    *
4    * The Netty Project licenses this file to you under the Apache License,
5    * version 2.0 (the "License"); you may not use this file except in compliance
6    * with the License. You may obtain a copy of the License at:
7    *
8    *   https://www.apache.org/licenses/LICENSE-2.0
9    *
10   * Unless required by applicable law or agreed to in writing, software
11   * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
12   * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
13   * License for the specific language governing permissions and limitations
14   * under the License.
15   */
16  
17  package io.netty.util.concurrent;
18  
19  import io.netty.util.internal.ObjectUtil;
20  import io.netty.util.internal.StringUtil;
21  
22  import java.util.Locale;
23  import java.util.concurrent.ThreadFactory;
24  import java.util.concurrent.atomic.AtomicInteger;
25  
26  /**
27   * A {@link ThreadFactory} implementation with a simple naming rule.
28   */
29  public class DefaultThreadFactory implements ThreadFactory {
30  
31      private static final AtomicInteger poolId = new AtomicInteger();
32  
33      private final AtomicInteger nextId = new AtomicInteger();
34      private final String prefix;
35      private final boolean daemon;
36      private final int priority;
37      protected final ThreadGroup threadGroup;
38  
39      public DefaultThreadFactory(Class<?> poolType) {
40          this(poolType, false, Thread.NORM_PRIORITY);
41      }
42  
43      public DefaultThreadFactory(String poolName) {
44          this(poolName, false, Thread.NORM_PRIORITY);
45      }
46  
47      public DefaultThreadFactory(Class<?> poolType, boolean daemon) {
48          this(poolType, daemon, Thread.NORM_PRIORITY);
49      }
50  
51      public DefaultThreadFactory(String poolName, boolean daemon) {
52          this(poolName, daemon, Thread.NORM_PRIORITY);
53      }
54  
55      public DefaultThreadFactory(Class<?> poolType, int priority) {
56          this(poolType, false, priority);
57      }
58  
59      public DefaultThreadFactory(String poolName, int priority) {
60          this(poolName, false, priority);
61      }
62  
63      public DefaultThreadFactory(Class<?> poolType, boolean daemon, int priority) {
64          this(toPoolName(poolType), daemon, priority);
65      }
66  
67      public static String toPoolName(Class<?> poolType) {
68          ObjectUtil.checkNotNull(poolType, "poolType");
69  
70          String poolName = StringUtil.simpleClassName(poolType);
71          switch (poolName.length()) {
72              case 0:
73                  return "unknown";
74              case 1:
75                  return poolName.toLowerCase(Locale.US);
76              default:
77                  if (Character.isUpperCase(poolName.charAt(0)) && Character.isLowerCase(poolName.charAt(1))) {
78                      return Character.toLowerCase(poolName.charAt(0)) + poolName.substring(1);
79                  } else {
80                      return poolName;
81                  }
82          }
83      }
84  
85      public DefaultThreadFactory(String poolName, boolean daemon, int priority, ThreadGroup threadGroup) {
86          ObjectUtil.checkNotNull(poolName, "poolName");
87  
88          if (priority < Thread.MIN_PRIORITY || priority > Thread.MAX_PRIORITY) {
89              throw new IllegalArgumentException(
90                      "priority: " + priority + " (expected: Thread.MIN_PRIORITY <= priority <= Thread.MAX_PRIORITY)");
91          }
92  
93          prefix = poolName + '-' + poolId.incrementAndGet() + '-';
94          this.daemon = daemon;
95          this.priority = priority;
96          this.threadGroup = threadGroup;
97      }
98  
99      public DefaultThreadFactory(String poolName, boolean daemon, int priority) {
100         this(poolName, daemon, priority, null);
101     }
102 
103     @Override
104     public Thread newThread(Runnable r) {
105         Thread t = newThread(FastThreadLocalRunnable.wrap(r), prefix + nextId.incrementAndGet());
106         try {
107             if (t.isDaemon() != daemon) {
108                 t.setDaemon(daemon);
109             }
110 
111             if (t.getPriority() != priority) {
112                 t.setPriority(priority);
113             }
114         } catch (Exception ignored) {
115             // Doesn't matter even if failed to set.
116         }
117         return t;
118     }
119 
120     protected Thread newThread(Runnable r, String name) {
121         return new FastThreadLocalThread(threadGroup, r, name);
122     }
123 }