/*
* Copyright 2013 The Netty Project
*
* The Netty Project licenses this file to you 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 io.netty.util.concurrent;
import io.netty.util.internal.
StringUtil;
import java.util.
Locale;
import java.util.concurrent.
ThreadFactory;
import java.util.concurrent.atomic.
AtomicInteger;
/**
* A {@link ThreadFactory} implementation with a simple naming rule.
*/
public class
DefaultThreadFactory implements
ThreadFactory {
private static final
AtomicInteger poolId = new
AtomicInteger();
private final
AtomicInteger nextId = new
AtomicInteger();
private final
String prefix;
private final boolean
daemon;
private final int
priority;
protected final
ThreadGroup threadGroup;
public
DefaultThreadFactory(
Class<?>
poolType) {
this(
poolType, false,
Thread.
NORM_PRIORITY);
}
public
DefaultThreadFactory(
String poolName) {
this(
poolName, false,
Thread.
NORM_PRIORITY);
}
public
DefaultThreadFactory(
Class<?>
poolType, boolean
daemon) {
this(
poolType,
daemon,
Thread.
NORM_PRIORITY);
}
public
DefaultThreadFactory(
String poolName, boolean
daemon) {
this(
poolName,
daemon,
Thread.
NORM_PRIORITY);
}
public
DefaultThreadFactory(
Class<?>
poolType, int
priority) {
this(
poolType, false,
priority);
}
public
DefaultThreadFactory(
String poolName, int
priority) {
this(
poolName, false,
priority);
}
public
DefaultThreadFactory(
Class<?>
poolType, boolean
daemon, int
priority) {
this(
toPoolName(
poolType),
daemon,
priority);
}
public static
String toPoolName(
Class<?>
poolType) {
if (
poolType == null) {
throw new
NullPointerException("poolType");
}
String poolName =
StringUtil.
simpleClassName(
poolType);
switch (
poolName.
length()) {
case 0:
return "unknown";
case 1:
return
poolName.
toLowerCase(
Locale.
US);
default:
if (
Character.
isUpperCase(
poolName.
charAt(0)) &&
Character.
isLowerCase(
poolName.
charAt(1))) {
return
Character.
toLowerCase(
poolName.
charAt(0)) +
poolName.
substring(1);
} else {
return
poolName;
}
}
}
public
DefaultThreadFactory(
String poolName, boolean
daemon, int
priority,
ThreadGroup threadGroup) {
if (
poolName == null) {
throw new
NullPointerException("poolName");
}
if (
priority <
Thread.
MIN_PRIORITY ||
priority >
Thread.
MAX_PRIORITY) {
throw new
IllegalArgumentException(
"priority: " +
priority + " (expected: Thread.MIN_PRIORITY <= priority <= Thread.MAX_PRIORITY)");
}
prefix =
poolName + '-' +
poolId.
incrementAndGet() + '-';
this.
daemon =
daemon;
this.
priority =
priority;
this.
threadGroup =
threadGroup;
}
public
DefaultThreadFactory(
String poolName, boolean
daemon, int
priority) {
this(
poolName,
daemon,
priority,
System.
getSecurityManager() == null ?
Thread.
currentThread().
getThreadGroup() :
System.
getSecurityManager().
getThreadGroup());
}
@
Override
public
Thread newThread(
Runnable r) {
Thread t =
newThread(
FastThreadLocalRunnable.
wrap(
r),
prefix +
nextId.
incrementAndGet());
try {
if (
t.
isDaemon() !=
daemon) {
t.
setDaemon(
daemon);
}
if (
t.
getPriority() !=
priority) {
t.
setPriority(
priority);
}
} catch (
Exception ignored) {
// Doesn't matter even if failed to set.
}
return
t;
}
protected
Thread newThread(
Runnable r,
String name) {
return new
FastThreadLocalThread(
threadGroup,
r,
name);
}
}