Java ExecutorService四种线程池基本介绍以及相关举例

1、new Thread的弊端

执行一个异步任务你还只是如下new Thread吗？

new Thread(new Runnable() {

    @Override
    public void run() {
        // TODO Auto-generated method stub
    }
}).start();

那你就out太多了，new Thread的弊端如下：
a. 每次new Thread新建对象性能差。
b. 线程缺乏统一管理，可能无限制新建线程，相互之间竞争，及可能占用过多系统资源导致死机或oom。
c. 缺乏更多功能，如定时执行、定期执行、线程中断。
相比new Thread，Java提供的四种线程池的好处在于：
a. 重用存在的线程，减少对象创建、消亡的开销，性能佳。
b. 可有效控制最大并发线程数，提高系统资源的使用率，同时避免过多资源竞争，避免堵塞。
c. 提供定时执行、定期执行、单线程、并发数控制等功能。

2、Java 线程池
Java通过Executors提供四种线程池，分别为：
newCachedThreadPool创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。
newFixedThreadPool 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。
newScheduledThreadPool 创建一个定长线程池，支持定时及周期性任务执行。
newSingleThreadExecutor 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。

3、以下例子是我在公司编写代码时所执行的基本方案

package com.shuang.executorservice;

import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

/**
 * ExecutorService线程池的使用
 * 这里只是执行了一个线程的任务为例
 * @author shuang
 *
 */
public class ExecutorServiceTest {
	
	//线程运行后需要得到的结果之一
	private String strString = null;
	//实例化
	private static ExecutorServiceTest INSTANCE = new ExecutorServiceTest();
	
	//获取单实例
	public static ExecutorServiceTest getInstance(){
		return INSTANCE;
	} 
	
	//构造方法私有化
	private ExecutorServiceTest(){
		
		
		ExecutorService executor = null;
		try {
			executor = Executors.newFixedThreadPool(3, new SelfThreadFactory("shuang-thread"));

			Future<String> future = executor.submit(new TestTask());
			
			strString = future.get();
		} catch (InterruptedException e) {
			e.printStackTrace();
		} catch (ExecutionException e) {
			e.printStackTrace();
		}finally {
			if(executor != null){
				executor.shutdown();
			}
		}
	}
	public String getStrString(){
		return strString;
	}
	
	

}

package com.shuang.executorservice;

import java.util.concurrent.ThreadFactory;
import java.util.concurrent.atomic.AtomicInteger;
/**
 * 线程工厂
 * @author shuang
 *
 */
public class SelfThreadFactory implements ThreadFactory {
	//线程组
	private final ThreadGroup group;
	//可以使用院子方式更新的int值。有关院子变量属性的描述
	private final AtomicInteger threadNumber = new AtomicInteger(1);
	//线程名前缀
	private final String namePrefix;
	
	/**
	 * 构造器
	 * @param name 线程名
	 */
	public SelfThreadFactory(String name) {
		//安全管理器，相关介绍可以看APi文档
		SecurityManager securityManager = System.getSecurityManager();
		group = securityManager == null?Thread.currentThread().getThreadGroup():securityManager.getThreadGroup();
		namePrefix = new StringBuilder().append(name).append("-").toString();
	}

	@Override
	public Thread newThread(Runnable target) {
		//分配新的Thread对象，以便将target作为其中运行对象。
		//将指定的name作为其名称，作为group所引用的线程组的一员，并具有指定的堆栈大小
		
		Thread thread =new Thread(
				group, 
				target, 
				new StringBuilder().append(namePrefix).append(threadNumber.getAndIncrement()).toString(), 
				0);
		if(thread.isDaemon()){//守护线程
			thread.setDaemon(false);
		}
		if(thread.getPriority() != 5){//优先级
			thread.setPriority(5);
		}
		return thread;
	}

}

package com.shuang.executorservice;

import java.util.concurrent.Callable;
/**
 * 测试任务类-其中一个
 * @author shuang
 *
 */
public class TestTask implements Callable<String> {

	@Override
	public String call() throws Exception {
		return "this is OK!";
	}


}

package com.shuang.executorservice;
//测试类
public class Test {
	public static void main(String[] args) {
		System.out.println(ExecutorServiceTest.getInstance().getStrString());
	}
}

基本介绍来自这个地址：https://www.cnblogs.com/zhaoyan001/p/7049627.html