java自定义线程池util_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(),new MyThreadFactory("MyThreadFactory"),new ThreadPoolExecutor.AbortPolicy());

//获取ThreadPoolExecutor，调用execute()方法，传入一个实现Runnable接口的实现类即可

public static ThreadPoolExecutor getExe() {

return poolExe;

}

}Task类

package thread;

public class Task implements Runnable {

@Override

public void run() {

// TODO Auto-generated method stub

System.out.println("Task类中的run方法！");

}

}Main

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();

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)