线程工厂 ThreadFactory

工厂模式是我们学习编程时，接触到的第一个设计模式，也是最简单、最常用的一个设计模式。在JDK的源码中，大量使用工厂模式，ThreadFactory就是其中一种。

在我们一般的使用中，创建一个线程，通常有两种方式:

• 继承Thread类，覆盖run方法，实现我们需要的业务
• 继承Runnable接口，实现run方法，实现我们需要的业务，并且调用new Thread(Runnable)方法，将其包装为一个线程执行

设想这样一种场景，我们需要一个线程池，并且对于线程池中的线程对象，赋予统一的线程优先级、统一的名称、甚至进行统一的业务处理或和业务方面的初始化工作，这时工厂方法就是最好用的方法了

ThreadFactory接口

ThreadFactory接口很简单，源码如下：

[java] view plain copy

1. public interface ThreadFactory {  
2.     Thread newThread(Runnable r);  
3. }  

我们可以看到ThreadFactory中，只有一个newThread方法，它负责接收一个Runnable对象，并将其封装到Thread对象中，进行执行。

最简单的ThreadFactory实现

我们可以实现上述接口，做一个最简单的线程工厂出来，源码如下：

[java] view plain copy

1. public class SimpleThreadFactory implements ThreadFactory{  
2.     @Override  
3.     public Thread newThread(Runnable r) {  
4.         return new Thread(r);  
5.     }  
6. }  

上述线程工厂，只是创建了一个新线程，其他什么都没干。实际使用时，一般不会创建这么简单的线程工厂。

[java] view plain copy

1. public class FixCountThreadFactory implements ThreadFactory{  
2.     private final int MAX_THREAD;  
3.       
4.     private final AtomicInteger count = new AtomicInteger(0);  
5.       
6.     public FixCountThreadFactory(int maxThread) {  
7.         MAX_THREAD = maxThread;  
8.     }  
9.       
10.     @Override  
11.     public Thread newThread(Runnable r) {  
12.         int incrementAndGet = count.incrementAndGet();  
13.         if(incrementAndGet > MAX_THREAD)  
14.         {  
15.             count.decrementAndGet();  
16.             return null;  
17.         }  
18.           
19.         return new Thread(r);  
20.     }  
21. }  

上述线程工厂，可以控制创建线程的总数。

JDK中默认的线程工厂

在Executors工具类中，JDK提供了一个非常简单的线程工程，源码如下：

[java] view plain copy

1. static class DefaultThreadFactory implements ThreadFactory {  
2.    static final AtomicInteger poolNumber = new AtomicInteger(1);  
3.    final ThreadGroup group;  
4.    final AtomicInteger threadNumber = new AtomicInteger(1);  
5.    final String namePrefix;  
6.   
7.    DefaultThreadFactory() {  
8.        SecurityManager s = System.getSecurityManager();  
9.        group = (s != null)? s.getThreadGroup() :  
10.                             Thread.currentThread().getThreadGroup();  
11.        namePrefix = "pool-" +  
12.                      poolNumber.getAndIncrement() +  
13.                     "-thread-";  
14.    }  
15.   
16.    public Thread newThread(Runnable r) {  
17.        Thread t = new Thread(group, r,  
18.                              namePrefix + threadNumber.getAndIncrement(),  
19.                              0);  
20.        if (t.isDaemon())  
21.            t.setDaemon(false);  
22.        if (t.getPriority() != Thread.NORM_PRIORITY)  
23.            t.setPriority(Thread.NORM_PRIORITY);  
24.        return t;  
25.    }