Java ThreadFactory接口用法与源码实现

最新推荐文章于 2024-07-10 10:59:08 发布

龙骨

最新推荐文章于 2024-07-10 10:59:08 发布

阅读量2.3k

点赞数

分类专栏：大数据，多线程

大数据，多线程专栏收录该内容

31 篇文章 0 订阅

订阅专栏

ThreadFactory这个故名思义，就是一个线程工厂。用来创建线程。这里为什么要使用线程工厂呢？其实就是为了统一在创建线程时设置一些参数，如是否守护线程。线程一些特性等，如优先级。通过这个TreadFactory创建出来的线程能保证有相同的特性。下面来看看它的源码吧

它首先是一个接口类，而且方法只有一个。就是创建一个线程。

一、线程工厂 ThreadFactory源码解读

ThreadFactory接口

ThreadFactory接口很简单，源码如下


public interface ThreadFactory {

Thread newThread(Runnable r);

}

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

    public class SimpleThreadFactory implements ThreadFactory{  
        @Override  
        public Thread newThread(Runnable r) {  
            return new Thread(r);  
        }  
    }

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

    public class FixCountThreadFactory implements ThreadFactory{  
        private final int MAX_THREAD;  
          
        private final AtomicInteger count = new AtomicInteger(0);  
          
        public FixCountThreadFactory(int maxThread) {  
            MAX_THREAD = maxThread;  
        }  
          
        @Override  
        public Thread newThread(Runnable r) {  
            int incrementAndGet = count.incrementAndGet();  
            if(incrementAndGet > MAX_THREAD)  
            {  
                count.decrementAndGet();  
                return null;  
            }  
              
            return new Thread(r);  
        }  
    }

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

JDK中默认的线程工厂

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

    static class DefaultThreadFactory implements ThreadFactory {  
       static final AtomicInteger poolNumber = new AtomicInteger(1);  
       final ThreadGroup group;  
       final AtomicInteger threadNumber = new AtomicInteger(1);  
       final String namePrefix;  
      
       DefaultThreadFactory() {  
           SecurityManager s = System.getSecurityManager();  
           group = (s != null)? s.getThreadGroup() :  
                                Thread.currentThread().getThreadGroup();  
           namePrefix = "pool-" +  
                         poolNumber.getAndIncrement() +  
                        "-thread-";  
       }  
      
       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;  
       }

二最简单的ThreadFactory实现

我们可以实现上述接口，做一个最简单的线程工厂出来，源码如下：
根据需要创建新线程的对象。使用线程工厂就无需再手工编写对 new Thread 的调用了，从而允许应用程序使用特殊的线程子类、属性等等。

JDK中的介绍：

An object that creates new threads on demand. Using thread factories removes hardwiring of calls tonew Thread, enabling applications to use special thread subclasses, priorities, etc.

The simplest implementation of this interface is just:

[java] view plain copy print ?

class SimpleThreadFactory implements ThreadFactory {
public Thread newThread(Runnable r) {
return new Thread(r);
}
}

The Executors.defaultThreadFactory method provides a more useful simple implementation, that sets the created thread context to known values before returning it.

[java] view plain copy print ?

/**
* The default thread factory
*/
static class DefaultThreadFactory implements ThreadFactory {
static final AtomicInteger poolNumber = new AtomicInteger(1);
final ThreadGroup group;
final AtomicInteger threadNumber = new AtomicInteger(1);
final String namePrefix;
DefaultThreadFactory() {
SecurityManager s = System.getSecurityManager();
group = (s != null)? s.getThreadGroup() :
Thread.currentThread().getThreadGroup();
namePrefix = "pool-" +
poolNumber.getAndIncrement() +
"-thread-";
}
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;
}
}

下面写一简单示例。

[java] view plain copy print ?

package com.test;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadFactory;
class Task implements Runnable{
int taskId;
public Task(int taskId) {
this.taskId=taskId;
}
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+"--taskId: "+taskId);
}
}
class DaemonThreadFactory implements ThreadFactory {
@Override
public Thread newThread(Runnable r) {
Thread t=new Thread(r);
t.setDaemon(true);
return t;
}
}
public class ThreadFactoryTest {
public static void main(String[] args) {
ExecutorService exec=Executors.newFixedThreadPool(3,new DaemonThreadFactory());
for(int i=0;i<3;i++) {
exec.submit(new Task(i));
}
exec.shutdown();
}
}

输出如下：

Thread-0--taskId: 0
Thread-1--taskId: 1
Thread-2--taskId: 2

分析：

DaemonThreadFactory中覆写的newThread()方法与submit()方法的调用关系，也就是说 DaemonThreadFactory是如何起作用的。

调试输出其调用关系：

也就是说，submit()时会调用DaemonThreadFactory类的newThread()方法来创建线程。

三、java.util.concurrent 接口 ThreadFactory

public interface ThreadFactory

根据需要创建新线程的对象。使用线程工厂就无需再手工编写对 new Thread 的调用了，从而允许应用程序使用特殊的线程子类、属性等等。

此接口最简单的实现就是：

 class SimpleThreadFactory implements ThreadFactory {
   public Thread newThread(Runnable r) {
     return new Thread(r);
   }
 }

Executors.defaultThreadFactory() 方法提供了更有用的简单实现，即在返回线程前将已创建线程的上下文设置为已知的值。

从以下版本开始：

1.5

方法摘要
`Thread`	`newThread(Runnable r)` 构造一个新 `Thread`。

方法详细信息

newThread

Thread newThread(Runnable r)

构造一个新 Thread。实现也可能初始化属性、名称、守护程序状态、 ThreadGroup 等等。

参数：

r - 由新线程实例所执行的可运行线程

返回：

构造的线程，如果请求创建线程被拒绝，则返回 null

转：http://blog.csdn.net/xin_jmail/article/details/22183175

龙骨

关注

0
点赞
踩
5

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录