java线程池之java自带的四种线程池_java如何使用三种默认线程池-优快云博客

本文链接：https://blog.youkuaiyun.com/wx5040257/article/details/78035368

使用ThreadPoolExecutor创建线程池比较麻烦，对于很多人来说不易使用，所以java已经帮我们设计好了四种线程池。查看java源代码发现这四种线程池仍然是由ThreadPoolExecutor创建的，只不过把相关的参数已经设计好了而已。

案例一：同时演示三种线程池

/*
 * 任务类
 */
class MyTask implements Runnable {
	String theTask;

	public MyTask(String theTask) {
		this.theTask = theTask;
	}

	public void run() {
		System.out.println("正在执行" + theTask);
		try {
			// 需要一定时间秒执行完毕
			Thread.currentThread().sleep((long) (Math.random() * 10000));
		} catch (InterruptedException e) {
			System.out.println("线程:" + theTask + "被中断");
		}
		System.out.println("线程:" + theTask + "执行完毕");
	}
}

====================================

/*
 * 主线程类
 */
public class ThreadPoolTest3 {
	public static void main(String[] args) {
		//创建自动扩充大小的线程池对象
		ExecutorService cachedThreadPool=Executors.newCachedThreadPool();
		//创建一个固定并发数为3的线程池对象
		ExecutorService fixThreadPool=Executors.newFixedThreadPool(3);
		//创建一个只能一次跑一个任务的线程池对象，保证所有的任务先进先出
		ExecutorService singleThreadPool=Executors.newSingleThreadExecutor();
		try {
			//执行10个任务
			for (int i = 1; i <= 10; i++) {
				MyTask myTask = new MyTask("task==" + i);
				cachedThreadPool.execute(myTask);
				//fixThreadPool.execute(myTask);
				//singleThreadPool.execute(myTask);
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
		cachedThreadPool.shutdown();
	}
}

(1) newCachedThreadPool

这个使用得最多，通常称为自动扩充大小的线程池。可以查看其源代码：

public static ExecutorService newCachedThreadPool() {
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                      60L, TimeUnit.SECONDS,
                                      new SynchronousQueue<Runnable>());
    }

官方解释如下：创建一个可根据需要创建新线程的线程池，但是在以前构造的线程可用时将重用它们。对于执行很多短期异步任务的程序而言，这些线程池通常可提高程序性能。调用 execute 将重用以前构造的线程（如果线程可用）。如果现有线程没有可用的，则创建一个新线程并添加到池中。终止并从缓存中移除那些已有 60 秒钟未被使用的线程。因此，长时间保持空闲的线程池不会使用任何资源。

要点：1.自动扩充大小，没有容量限制。2.空闲线程超过60秒会被移除。3.排队队列没有长度限制
采用newCachedThreadPool执行结果如下：

正在执行task==2
正在执行task==4
正在执行task==6
正在执行task==8
正在执行task==10
正在执行task==1
正在执行task==3
正在执行task==5
正在执行task==7
正在执行task==9
线程:task==4执行完毕
线程:task==5执行完毕
线程:task==8执行完毕
线程:task==10执行完毕
线程:task==9执行完毕
线程:task==3执行完毕
线程:task==1执行完毕
线程:task==6执行完毕
线程:task==2执行完毕
线程:task==7执行完毕

(2) newFixedThreadPool

创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。可以查看其源代码:

public static ExecutorService newFixedThreadPool(int nThreads) {
        return new ThreadPoolExecutor(nThreads, nThreads,
                                      0L, TimeUnit.MILLISECONDS,
                                      new LinkedBlockingQueue<Runnable>());
    }

要点：1. 线程数量固定 2. 排队队列没有长度限制 3.固定的那几个线程就算空闲也不会被移除

采用newFixedThreadPool执行结果如下：

正在执行task==2
正在执行task==1
正在执行task==3
线程:task==3执行完毕
正在执行task==4
线程:task==4执行完毕
正在执行task==5
线程:task==2执行完毕
正在执行task==6
线程:task==1执行完毕
正在执行task==7
线程:task==5执行完毕
正在执行task==8
线程:task==6执行完毕
正在执行task==9
线程:task==7执行完毕
正在执行task==10
线程:task==8执行完毕
线程:task==9执行完毕
线程:task==10执行完毕

(3) newSingleThreadExecutor

创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。可以查看其源代码:

public static ExecutorService newSingleThreadExecutor() {
        return new FinalizableDelegatedExecutorService
            (new ThreadPoolExecutor(1, 1,
                                    0L, TimeUnit.MILLISECONDS,
                                    new LinkedBlockingQueue<Runnable>()));
    }

要点：1.核心线程数和最大线程数都是1 2. 就算空闲也不会被移除 3.排队队列没有长度限制 4.保证是先进先出的方式进行
采用 newSingleThreadExecutor 执行结果如下：

正在执行task==1
线程:task==1执行完毕
正在执行task==2
线程:task==2执行完毕
正在执行task==3
线程:task==3执行完毕
正在执行task==4
线程:task==4执行完毕
正在执行task==5
线程:task==5执行完毕
正在执行task==6
线程:task==6执行完毕
正在执行task==7
线程:task==7执行完毕
正在执行task==8
线程:task==8执行完毕
正在执行task==9
线程:task==9执行完毕
正在执行task==10
线程:task==10执行完毕

案例二：演示newScheduledThreadPool的使用

/*
 * 任务类
 */
class MyTask implements Runnable {
	String theTask;

	public MyTask(String theTask) {
		this.theTask = theTask;
	}

	public void run() {
		SimpleDateFormat sdf=new SimpleDateFormat("HH:mm:ss:SSS");
		System.out.println("线程开始时间:"+sdf.format(new Date()));
		System.out.println("正在执行" + theTask);
		try {
			// 需要一定时间秒执行完毕
			Thread.currentThread().sleep(10);
		} catch (InterruptedException e) {
			System.out.println("线程:" + theTask + "被中断");
		}
		System.out.println("线程结束时间:"+sdf.format(new Date()));
		System.out.println("线程:" + theTask + "执行完毕");
	}
}

=======================

/*
 * 主线程类
 */
public class ThreadPoolTest3 {
	public static void main(String[] args) {
		//创建一个定长线程池，支持定时及周期性任务执行
		ScheduledExecutorService scheduledThreadPool
		                          =Executors.newScheduledThreadPool(3);
		//精确到毫秒
		SimpleDateFormat sdf=new SimpleDateFormat("HH:mm:ss:SSS");
		System.out.println("当前时间点:"+sdf.format(new Date()));
		try {
			MyTask myTask = new MyTask("task==1");
			//3秒后执行一次
			//scheduledThreadPool.schedule(myTask,3,TimeUnit.SECONDS);
			//5秒后开始执行，然后每隔2秒执行一次
			scheduledThreadPool.scheduleAtFixedRate(myTask,5,2,TimeUnit.SECONDS);
		} catch (Exception e) {
			e.printStackTrace();
		}
		//scheduledThreadPool.shutdown();
	}
}

=======================

(4) newScheduledThreadPool
创建一个定长线程池，支持定时及周期性任务执行。

要点：1.可以定时到多少时间之后启动线程 2.可以启动后在固定的时间周期里重复执行线程。例如可以让线程在5秒后执行，也可以设定为在5秒后每隔2秒执行一次。

//3秒后执行一次
scheduledThreadPool.schedule(myTask,3,TimeUnit.SECONDS);

结果如下：

当前时间点:23:38:39:746
线程开始时间:23:38:42:748
正在执行task==1
线程结束时间:23:38:42:758
线程:task==1执行完毕

//5秒后开始执行，然后每隔2秒执行一次
scheduledThreadPool.scheduleAtFixedRate(myTask,5,2,TimeUnit.SECONDS);
结果如下：

当前时间点:23:26:35:594
线程开始时间:23:26:40:598
正在执行task==1
线程结束时间:23:26:40:608
线程:task==1执行完毕
线程开始时间:23:26:42:598
正在执行task==1
线程结束时间:23:26:42:608
线程:task==1执行完毕
线程开始时间:23:26:44:598
正在执行task==1
线程结束时间:23:26:44:608
线程:task==1执行完毕
线程开始时间:23:26:46:598
正在执行task==1
线程结束时间:23:26:46:608
线程:task==1执行完毕
线程开始时间:23:26:48:598
正在执行task==1
线程结束时间:23:26:48:608
线程:task==1执行完毕
线程开始时间:23:26:50:598
正在执行task==1
线程结束时间:23:26:50:608
线程:task==1执行完毕