ThreadFactory的理解
ThreadFactory：就像一个代理类。在创建一个线程的时候，通过实现ThreadFactory接口的类对象，就会监听到它，从而执行ThreadFactory的newThread（Runnable r）方法。把该线程传人方法中，你就可以在方法中对线程进行一些操作（如，给线程起名字，把线程封装到那个组，修改线程的优先级等等。）最后会把包装过的线程，放入jvm中去执行。
首先来构建线程封装类WorkThread,该类的功能主要是为了能够更好的管理线程而创建的
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
public
class
WorkThread
extends
Thread {
private
Runnable target;
//线程执行目标
private
AtomicInteger counter;
public
WorkThread(Runnable target, AtomicInteger counter) {
this
.target = target;
this
.counter = counter;
}
@Override
public
void
run() {
try
{
target.run();
}
finally
{
int
c = counter.getAndDecrement();
System.out.println(
"terminate no "
+ c +
" Threads"
);
}
}
}
|
其次，来定义一个测试目标
|
1
2
3
4
5
6
7
8
|
public
class
WorkRunnable
implements
Runnable
{
@Override
public
void
run() {
System.out.println(
"complete a task"
);
}
}
|
实现线程工厂的方法
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
public
class
WorkThreadFactory
implements
ThreadFactory{
private
AtomicInteger atomicInteger =
new
AtomicInteger(
0
);
@Override
public
Thread newThread(Runnable r)
{
int
c = atomicInteger.incrementAndGet();
System.out.println(
"create no "
+ c +
" Threads"
);
return
new
WorkThread(r, atomicInteger);
//通过计数器，可以更好的管理线程
}
}
|
测试线程工厂
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
|
public
class
TestThreadFactory {
public
static
void
main(String[] args) {
//创建线程（并发）池，自动伸缩(自动条件线程池大小)
ExecutorService es = Executors.newCachedThreadPool(
new
WorkThreadFactory());
//同时并发5个工作线程
es.execute(
new
WorkRunnable());
es.execute(
new
WorkRunnable());
es.execute(
new
WorkRunnable());
es.execute(
new
WorkRunnable());
es.execute(
new
WorkRunnable());
//指示当所有线程执行完毕后关闭线程池和工作线程，如果不调用此方法，jvm不会自动关闭
es.shutdown();
try
{
//等待线程执行完毕，不能超过2*60秒，配合shutDown
es.awaitTermination(
2
*
60
, TimeUnit.SECONDS);
}
catch
(InterruptedException e) {
e.printStackTrace();
}
}
}
|
线程工厂是一个接口，它用于根据需要创建新线程的对象。使用线程工厂就无需再手工编写对new Thread的调用了，从而允许应用程序使用特殊的线程子类、属性等等。
（相当于创建好了线程，分好了组，要用线程就直接在组里，执行要执行的线程）
static class GameThreadFactory implements ThreadFactory {
// static final AtomicInteger poolNumber = new AtomicInteger(1);
final ThreadGroup group;
final AtomicInteger threadNumber = new AtomicInteger(1);
final String namePrefix;
public GameThreadFactory(ExecutorType poolType) {
SecurityManager s = System.getSecurityManager(); //获得系统安全接口
group = (s != null)? s.getThreadGroup() : //在接口中获得线程的分组
Thread.currentThread().getThreadGroup(); //获得当前线程所在组
namePrefix = "pool-" +
poolType.toString()+
"-thread-";
}
@Override
public Thread newThread(Runnable r) {
Thread t = new Thread(group, r,namePrefix + threadNumber.getAndIncrement(),
0); //新建一个指定组，名字，所占堆大小的线程。
if (t.isDaemon())
t.setDaemon(false);
if (t.getPriority() != Thread.NORM_PRIORITY)
t.setPriority(Thread.NORM_PRIORITY);
return t;
}
}
ThreadPoolExecutor t = new ThreadPoolExecutor(1, 1,0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<Runnable>(),new GameThreadFactory(etype)); //把它配置到线程池中管理.
使用：
t.execute(new Runnable() {
@Override
public void run() {
try{
hePlayers_UID_BINDING_AND_RESET_PWD_STATUS.put(pvo.getUid(),map);
}
}
}）；