BasicThreadFactory.java
3.8 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
package org.apache.commons.lang3.concurrent;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.atomic.AtomicLong;
import org.apache.commons.lang3.builder.Builder;
public class BasicThreadFactory
implements ThreadFactory
{
private final AtomicLong a;
private final ThreadFactory b;
private final Thread.UncaughtExceptionHandler c;
private final String d;
private final Integer e;
private final Boolean f;
private BasicThreadFactory(Builder paramBuilder)
{
if (Builder.a(paramBuilder) == null) {}
for (this.b = Executors.defaultThreadFactory();; this.b = Builder.a(paramBuilder))
{
this.d = Builder.b(paramBuilder);
this.e = Builder.c(paramBuilder);
this.f = Builder.d(paramBuilder);
this.c = Builder.e(paramBuilder);
this.a = new AtomicLong();
return;
}
}
public final Boolean getDaemonFlag()
{
return this.f;
}
public final String getNamingPattern()
{
return this.d;
}
public final Integer getPriority()
{
return this.e;
}
public long getThreadCount()
{
return this.a.get();
}
public final Thread.UncaughtExceptionHandler getUncaughtExceptionHandler()
{
return this.c;
}
public final ThreadFactory getWrappedFactory()
{
return this.b;
}
public Thread newThread(Runnable paramRunnable)
{
paramRunnable = getWrappedFactory().newThread(paramRunnable);
if (getNamingPattern() != null)
{
long l = this.a.incrementAndGet();
paramRunnable.setName(String.format(getNamingPattern(), new Object[] { Long.valueOf(l) }));
}
if (getUncaughtExceptionHandler() != null) {
paramRunnable.setUncaughtExceptionHandler(getUncaughtExceptionHandler());
}
if (getPriority() != null) {
paramRunnable.setPriority(getPriority().intValue());
}
if (getDaemonFlag() != null) {
paramRunnable.setDaemon(getDaemonFlag().booleanValue());
}
return paramRunnable;
}
public static class Builder
implements Builder<BasicThreadFactory>
{
private ThreadFactory a;
private Thread.UncaughtExceptionHandler b;
private String c;
private Integer d;
private Boolean e;
public BasicThreadFactory build()
{
BasicThreadFactory localBasicThreadFactory = new BasicThreadFactory(this, (byte)0);
reset();
return localBasicThreadFactory;
}
public Builder daemon(boolean paramBoolean)
{
this.e = Boolean.valueOf(paramBoolean);
return this;
}
public Builder namingPattern(String paramString)
{
if (paramString == null) {
throw new NullPointerException("Naming pattern must not be null!");
}
this.c = paramString;
return this;
}
public Builder priority(int paramInt)
{
this.d = Integer.valueOf(paramInt);
return this;
}
public void reset()
{
this.a = null;
this.b = null;
this.c = null;
this.d = null;
this.e = null;
}
public Builder uncaughtExceptionHandler(Thread.UncaughtExceptionHandler paramUncaughtExceptionHandler)
{
if (paramUncaughtExceptionHandler == null) {
throw new NullPointerException("Uncaught exception handler must not be null!");
}
this.b = paramUncaughtExceptionHandler;
return this;
}
public Builder wrappedFactory(ThreadFactory paramThreadFactory)
{
if (paramThreadFactory == null) {
throw new NullPointerException("Wrapped ThreadFactory must not be null!");
}
this.a = paramThreadFactory;
return this;
}
}
}
/* Location: /home/merong/decompile/hackery-dex2jar.jar!/org/apache/commons/lang3/concurrent/BasicThreadFactory.class
* Java compiler version: 6 (50.0)
* JD-Core Version: 0.7.1
*/