java.util.concurrent解读，自定义线程工厂，线程池

package thread;

import java.util.concurrent.ThreadFactory;
import java.util.concurrent.atomic.AtomicInteger;

public class MyThreadFactory implements ThreadFactory {

private final ThreadGroup threadGroup;

private final AtomicInteger threadNumber = new AtomicInteger(0);

private final String threadPrefix;

public MyThreadFactory(String name) {
//如果已经为当前应用程序建立了安全管理器，则返回此安全管理器；否则，返回 null
SecurityManager security = System.getSecurityManager();
//security.getThreadGroup()调用此方法时，返回所有新创建的线程实例化后所在的线程组。默认情况下，
//返回当前线程所在的线程组。应该由指定的安全管理器重写此方法，以返回适当的线程组。
threadGroup = (security!=null)?security.getThreadGroup():Thread.currentThread().getThreadGroup();
threadPrefix = name + "-thread-";
}

public Thread newThread(Runnable target) {
//以原子方式将当前值+1，最后一个参数指定线程的堆栈大小
Thread thread = new Thread(threadGroup,target,threadPrefix+threadNumber.getAndIncrement(),0);
//设置为非守护级线程
//守护级线程不属于程序的核心部分，当所有非守护级线程运行结束时，程序也就结束了
//只要还有非守护级线程存在，程序就不能结束
if(thread.isDaemon()) {
thread.setDaemon(false);
}
if(thread.getPriority()!=Thread.NORM_PRIORITY) {
thread.setPriority(Thread.NORM_PRIORITY);
}
System.out.println("执行了线程工厂的newThread()方法");
System.out.println("线程名："+thread.getName()+",线程组："+thread.getThreadGroup());
return thread;
}

}

package thread;

import java.util.concurrent.SynchronousQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class MyThreadPool {

//定义线程池,用给定的初始参数和默认被拒绝的执行处理程序创建新的 ThreadPoolExecutor
//corePoolSize - 池中所保存的线程数，包括空闲线程。
//maximumPoolSize - 池中允许的最大线程数。
//keepAliveTime - 当线程数大于核心时，此为终止前多余的空闲线程等待新任务的最长时间。
//unit - keepAliveTime 参数的时间单位。
//workQueue - 执行前用于保持任务的队列。此队列仅保持由 execute 方法提交的 Runnable 任务。
//factory - 指定线程工厂
//handler - 由于超出线程范围和队列容量而使执行被阻塞时所使用的处理程序。
private static ThreadPoolExecutor poolExe = new ThreadPoolExecutor(1,2,0,TimeUnit.SECONDS,
new SynchronousQueue<Runnable>(),new MyThreadFactory("MyThreadFactory"),new ThreadPoolExecutor.AbortPolicy());

//获取ThreadPoolExecutor，调用execute()方法，传入一个实现Runnable接口的实现类即可
public static ThreadPoolExecutor getExe() {
return poolExe;
}
}

package thread;

public class Task implements Runnable {

@Override
public void run() {
// TODO Auto-generated method stub
System.out.println("Task类中的run方法！");
}

}

package thread;

import java.io.File;
import java.util.Vector;
import java.util.concurrent.ThreadPoolExecutor;

public class Main {

public static void main(String[] args) {
// TODO Auto-generated method stub
ThreadPoolExecutor tpe = MyThreadPool.getExe();
Vector v = new Vector<Task>();
int i=0;
while(i<10) {
Task task = new Task();
tpe.execute(task);
i++;
}
}

}

执行了线程工厂的newThread()方法
线程名：MyThreadFactory-thread-0,线程组：java.lang.ThreadGroup[name=main,maxpri=10]
执行了线程工厂的newThread()方法
线程名：MyThreadFactory-thread-1,线程组：java.lang.ThreadGroup[name=main,maxpri=10]
Task类中的run方法！
Task类中的run方法！
Exception in thread "main" java.util.concurrent.RejectedExecutionException: Task thread.Task@20f5e814 rejected from java.util.concurrent.ThreadPoolExecutor@321ea24[Running, pool size = 1, active threads = 1, queued tasks = 0, completed tasks = 1]
at java.util.concurrent.ThreadPoolExecutor$AbortPolicy.rejectedExecution(Unknown Source)
at java.util.concurrent.ThreadPoolExecutor.reject(Unknown Source)
at java.util.concurrent.ThreadPoolExecutor.execute(Unknown Source)
at thread.Main.main(Main.java:17)