java线程池4种使用方式

Java通过Executors提供四种线程池，分别为：

newCachedThreadPool

可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。

newFixedThreadPoo

l创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。

newScheduledThreadPool

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

newSingleThreadExecutor

单线程化的线程池，用唯一的工作线程来执行，任务按照指定顺序(FIFO, LIFO, 优先级)执行。

1.newCachedThreadPool

package org.hornet.threadPool;
 
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
 
/*
 * 线程池的实现(java.util.concurrent.Executor接口)
 * Java通过Executors提供四种线程池，分别为：
 * newCachedThreadPool     创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。
 * newFixedThreadPool      创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。
 * newScheduledThreadPool  创建一个定长线程池，支持定时及周期性任务执行。
 * newSingleThreadExecutor 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。
 */
public class ThreadPoolDemo1 {
	
	static void threadDoSth(){
		System.out.println(Thread.currentThread().getName()+" 正在运行...");
	}
 
	public static void main(String[] args) throws Exception {
		
		/*
		 * 1.newCachedThreadPool
		 * 创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。
		 * 线程池为无限大，当执行第二个任务时第一个任务已经完成，会复用执行第一个任务的线程，而不用每次新建线程。
		 */
		ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
		//执行10次逻辑
		for(int i = 0 ;i < 10 ; i++) {
			cachedThreadPool.execute(new Runnable() {
				public void run() {
					threadDoSth();
				}
			});
		}
		//运行完毕，需要销毁线程池
		cachedThreadPool.shutdown(); 
		System.out.println("线程池已销毁");
	}

	
}

2.newFixedThreadPool

package org.hornet.threadPool;
 
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
 
/*
 * 线程池的实现(java.util.concurrent.Executor接口)
 * Java通过Executors提供四种线程池，分别为：
 * newCachedThreadPool     创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。
 * newFixedThreadPool      创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。
 * newScheduledThreadPool  创建一个定长线程池，支持定时及周期性任务执行。
 * newSingleThreadExecutor 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。
 */
public class ThreadPoolDemo2 {
	
	static void threadDoSth(){
		System.out.println(Thread.currentThread().getName()+" 正在运行...");
	}
 
	public static void main(String[] args) throws Exception {
		
		/*
		 * 2.newFixedThreadPool
		 * 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。
		 * 定长线程池的大小最好根据系统资源进行设置。如Runtime.getRuntime().availableProcessors()。
		 */
		ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);
		//执行10次逻辑
		for(int i = 0 ;i < 10 ; i++) {
			fixedThreadPool.execute(new Runnable() {
				public void run() {
					threadDoSth();
				}
			});
		}
		//运行完毕，需要销毁线程池
		fixedThreadPool.shutdown(); 
		System.out.println("线程池已销毁");
	}

	
}

3.newScheduledThreadPool

package org.hornet.threadPool;
 
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
 
/*
 * 线程池的实现(java.util.concurrent.Executor接口)
 * Java通过Executors提供四种线程池，分别为：
 * newCachedThreadPool     创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。
 * newFixedThreadPool      创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。
 * newScheduledThreadPool  创建一个定长线程池，支持定时及周期性任务执行。
 * newSingleThreadExecutor 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。
 */
public class ThreadPoolDemo3 {
	
	static void threadDoSth(){
		System.out.println(Thread.currentThread().getName()+" 正在运行...");
	}
	
	static void threadDoSthMore(){
		System.out.println(Thread.currentThread().getName()+" new正在运行...");
	}
 
	public static void main(String[] args) throws Exception {
		
		/*
		 * 3.newScheduledThreadPool
		 * 创建一个定长线程池，支持定时及周期性任务执行。
		 * ScheduledExecutorService比Timer更安全，功能更强大。
		 */
		ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
		//表示延迟3秒执行
//		scheduledThreadPool.schedule(new Runnable() {
//			public void run() {
//				threadDoSth();
//			}
//		}, 3, TimeUnit.SECONDS);
		
		//表示延迟1秒后每3秒执行一次
		scheduledThreadPool.scheduleAtFixedRate(new Runnable() {
			public void run() {
				threadDoSthMore();
			}
		}, 1, 3, TimeUnit.SECONDS);
				
		//运行完毕，需要销毁线程池
//		scheduledThreadPool.shutdown(); 
//		System.out.println("线程池已销毁");
	}

	
}

4.newSingleThreadExecutor

package org.hornet.threadPool;
 
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
 
/*
 * 线程池的实现(java.util.concurrent.Executor接口)
 * Java通过Executors提供四种线程池，分别为：
 * newCachedThreadPool     创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。
 * newFixedThreadPool      创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。
 * newScheduledThreadPool  创建一个定长线程池，支持定时及周期性任务执行。
 * newSingleThreadExecutor 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。
 */
public class ThreadPoolDemo4 {
	
	static void threadDoSth(){
		System.out.println(Thread.currentThread().getName()+" 正在运行...");
	}
	
	public static void main(String[] args) throws Exception {
		
		/*
		 * 4.newSingleThreadExecutor
		 * 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。
		 */
		ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();
		//执行10次逻辑
		for(int i = 0 ;i < 10 ; i++) {
			singleThreadExecutor.execute(new Runnable() {
				public void run() {
					threadDoSth();
				}
			});
		}
		//运行完毕，需要销毁线程池
		singleThreadExecutor.shutdown(); 
		System.out.println("线程池已销毁");
	}

	
}