java-自定义线程名称

2019独角兽企业重金招聘Python工程师标准>>>

功能中用到不止一个线程池，出错的时候不好排查是哪个池中的线程出错了，需要给每个线程命名，参考rt.jar中Executors类中线程池默认命名方式，自己实现了下。

先贴上源码

    /**
     * The default thread factory
     */
    static class DefaultThreadFactory implements ThreadFactory {
        private static final AtomicInteger poolNumber = new AtomicInteger(1);
        private final ThreadGroup group;
        private final AtomicInteger threadNumber = new AtomicInteger(1);
        private 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;
        }
    }

demo代码

package com.demo.thread.test20170830;

import java.util.concurrent.ThreadFactory;
import java.util.concurrent.atomic.AtomicInteger;
/**
 * 
 * @author fsw
 *
 */
public class MyThreadFactory implements ThreadFactory{
	
	private static final String DEFAULT_POOL_NAME_PREFIX = "test_pool_";
	private final AtomicInteger threadNumber = new AtomicInteger(1);
	private String pool_name_prefix;
	
	public MyThreadFactory() {
		this.pool_name_prefix = DEFAULT_POOL_NAME_PREFIX;
	}
	public MyThreadFactory(String name) {
		this.pool_name_prefix = name;
	}
	
	@Override
	public Thread newThread(Runnable r) {
		Thread thread = new Thread(r, pool_name_prefix + threadNumber.getAndIncrement());
		return thread;
	}

}

package com.demo.thread.test20170830;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.RejectedExecutionHandler;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class Main {

	public static void main(String[] args) {
		ThreadPoolExecutor executor = new ThreadPoolExecutor(5, 5, 0, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(2), new MyThreadFactory("this is pool name"), new RejectedExecutionHandler() {
			
			@Override
			public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
				try {
					if(executor.isShutdown()) {
						return;
					}
					executor.getQueue().put(r);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		});
		
		
		try {
			for (int i = 0; i < 10; i++) {
				executor.submit(new Runnable() {
					
					@Override
					public void run() {
						try {
							Thread.currentThread().sleep(3000);
							System.out.println(Thread.currentThread().getName());
						} catch (InterruptedException e) {
							e.printStackTrace();
						}
					}
				});
			}
		} finally {
			executor.shutdown();
		} 
	}
}

运行结果

转载于:https://my.oschina.net/u/3445128/blog/1526170