Java中线程组ThreadGroup与线程池的区别及示例

package cn.outofmemory.concurrent;
public class ThreadGroupDemo {
	public static void main(String[] args) {
		printGroupInfo(Thread.currentThread());
		Thread appThread = new Thread(new Runnable(){
			@Override
			public void run() {
				for (int i=0;i<5;i++) {
					System.out.println("do loop " + i);
				}
			}
		});
		appThread.setName("appThread");
		appThread.start();
		printGroupInfo(appThread);
	}
	static void printGroupInfo(Thread t) {
		ThreadGroup group = t.getThreadGroup();
		System.out.println("thread " + t.getName() + " group name is " 
				+ group.getName()+ " max priority is " + group.getMaxPriority()
				+ " thread count is " + group.activeCount());
		ThreadGroup parent=group;
		do {
			ThreadGroup current = parent;
			parent = parent.getParent();
			if (parent == null) {
				break;
			}
			System.out.println(current.getName() + "'s parent is " + parent.getName());
		} while (true);
		System.out.println("--------------------------");
	}
}

thread main group name is main max priority is 10 thread count is 1
main's parent is system
--------------------------
thread appThread group name is main max priority is 10 thread count is 2
main's parent is system
--------------------------
do loop 0
do loop 1
do loop 2
do loop 3
do loop 4

ThreadGroup group=new ThreadGroup("worker");
Thread thread=new Thread(group,"the first thread of group");

package cn.outofmemory.concurrent;
import java.net.SocketException;
public class ThreadGroupDemo2 {
	public static void main(String[] args) {
		ThreadGroup spiderGroup = new SpiderThreadGroup("spiderGroup");
		//可以统一设定线程是否为守护线程
		spiderGroup.setDaemon(true);
		//可以设置线程组内的最大优先级
		spiderGroup.setMaxPriority(Thread.NORM_PRIORITY);
		//初始化线程
		Thread spiderThread = new Thread(spiderGroup, new Runnable() {
			@Override
			public void run() {
				throw new RuntimeException(new SocketException());
			}
		});
		//启动线程
		spiderThread.start();
	}
	/**
	 * 此类从ThreadGroup类继承重写了其uncaughtException方法，对于SocketException进行了特殊处理
	 * @author outofmemory.cn
	 *
	 */
	static class SpiderThreadGroup extends ThreadGroup {
		public SpiderThreadGroup(String name) {
			super(name);
		}
		public void uncaughtException(Thread t, Throwable e) {
			if (e.getCause() instanceof SocketException) {
				System.out.println("socket exception should be process");
			} else {
				super.uncaughtException(t, e);
			}
		}
	}
}

package cn.outofmemory.concurrent;
public class ThreadDemo3 {
	public static void main(String[] args) {
		ThreadGroup g = Thread.currentThread().getThreadGroup();
		while (g != null) {
			ThreadGroup temp = g.getParent();
			if (temp == null) {
				break;
			}
			g = temp;
		}
		//现在g就是跟线程组
		System.out.println("active count is " + g.activeCount());
		Thread[] all = new Thread[g.activeCount()];
		g.enumerate(all);
		for (Thread t : all) {
			System.out.println(t.getName());
		}
	}
}

 public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory,
                              RejectedExecutionHandler handler) {
        if (corePoolSize < 0 ||
            maximumPoolSize <= 0 ||
            maximumPoolSize < corePoolSize ||
            keepAliveTime < 0)
            throw new IllegalArgumentException();
        if (workQueue == null || threadFactory == null || handler == null)
            throw new NullPointerException();
        this.corePoolSize = corePoolSize;
        this.maximumPoolSize = maximumPoolSize;
        this.workQueue = workQueue;
        this.keepAliveTime = unit.toNanos(keepAliveTime);
        this.threadFactory = threadFactory;
        this.handler = handler;
    }

public class DefaultThreadFactory implements ThreadFactory {
    private static final AtomicInteger poolId = new AtomicInteger();
    private final AtomicInteger nextId = new AtomicInteger();
    private final String prefix;
    private final boolean daemon;
    private final int priority;
    protected final ThreadGroup threadGroup;
    ......
}