通过线程池实现线程任务

最新推荐文章于 2024-08-15 17:50:34 发布

zidanlee

最新推荐文章于 2024-08-15 17:50:34 发布

阅读量205

点赞数 2

分类专栏：多线程

本文链接：https://blog.csdn.net/zidanlee/article/details/88654611

版权

多线程专栏收录该内容

1 篇文章 0 订阅

订阅专栏

为什么使用线程池？

1、创建/销毁线程伴随着系统开销，过于频繁的创建/销毁线程，会很大程度上影响处理效率

2、线程并发数量过多，抢占系统资源从而导致阻塞。运用线程池能有效的控制线程最大并发数，避免以上的问题

3、对线程进行一些简单的管理，比如：延时执行、定时循环执行的策略等

接口Executor的源代码，提供执行线程任务的方法：

public interface Executor {
    void execute(Runnable command);
}

接口ExecutorService继承自Executor，其中主要的几个方法如下：

public interface ExecutorService extends Executor {
    void shutdown();
    List<Runnable> shutdownNow();
    boolean isShutdown();
    boolean isTerminated();
    boolean awaitTermination(long timeout, TimeUnit unit)  throws InterruptedException;
    <T> Future<T> submit(Callable<T> task);
    <T> Future<T> submit(Runnable task, T result);
    Future<?> submit(Runnable task);
}

抽象类AbstractExecutorService实现了ExecutorService接口：

public abstract class AbstractExecutorService implements ExecutorService{
......
}

ThreadPoolExecutor继承自抽象类AbstractExecutorService，包含四个构造函数（重点关注第一个），在Executors中调用其构造函数用于创建线程池

public class ThreadPoolExecutor extends AbstractExecutorService{
public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit,
                              BlockingQueue<Runnable> workQueue)
......
}

参数说明：

int corePoolSize：该线程池中核心线程数最大值

核心线程：线程池新建线程的时候，如果当前线程总数小于corePoolSize，则新建的是核心线程，如果超过corePoolSize，则新建的是非核心线程

核心线程默认情况下会一直存活在线程池中，即使这个核心线程啥也不干(闲置状态)。

如果指定ThreadPoolExecutor的allowCoreThreadTimeOut这个属性为true，那么核心线程如果不干活(闲置状态)的话，超过一定时间(时长下面参数决定)，就会被销毁掉

int maximumPoolSize：该线程池中线程总数最大值

线程总数 = 核心线程数 + 非核心线程数。

long keepAliveTime：

该线程池中非核心线程闲置超时时长

一个非核心线程，如果不干活(闲置状态)的时长超过这个参数所设定的时长，就会被销毁掉

如果设置allowCoreThreadTimeOut = true，则会作用于核心线程

TimeUnit unit：

keepAliveTime的单位，TimeUnit是一个枚举类型，其包括：

NANOSECONDS ： 1微毫秒 = 1微秒 / 1000
MICROSECONDS ： 1微秒 = 1毫秒 / 1000
MILLISECONDS ： 1毫秒 = 1秒 /1000
SECONDS ：秒
MINUTES ：分
HOURS ：小时
DAYS ：天

BlockingQueue<Runnable> workQueue

该线程池中的任务队列：维护着等待执行的Runnable对象

当所有的核心线程都在干活时，新添加的任务会被添加到这个队列中等待处理，如果队列满了，则新建非核心线程执行任务

常用的workQueue类型：

SynchronousQueue：这个队列接收到任务的时候，会直接提交给线程处理，而不保留它，如果所有线程都在工作怎么办？那就新建一个线程来处理这个任务！所以为了保证不出现<线程数达到了maximumPoolSize而不能新建线程>的错误，使用这个类型队列的时候，maximumPoolSize一般指定成Integer.MAX_VALUE，即无限大
LinkedBlockingQueue：这个队列接收到任务的时候，如果当前线程数小于核心线程数，则新建线程(核心线程)处理任务；如果当前线程数等于核心线程数，则进入队列等待。由于这个队列没有最大值限制，即所有超过核心线程数的任务都将被添加到队列中，这也就导致了maximumPoolSize的设定失效，因为总线程数永远不会超过corePoolSize
ArrayBlockingQueue：可以限定队列的长度，接收到任务的时候，如果没有达到corePoolSize的值，则新建线程(核心线程)执行任务，如果达到了，则入队等候，如果队列已满，则新建线程(非核心线程)执行任务，又如果总线程数到了maximumPoolSize，并且队列也满了，则发生错误
DelayQueue：队列内元素必须实现Delayed接口，这就意味着你传进去的任务必须先实现Delayed接口。这个队列接收到任务时，首先先入队，只有达到了指定的延时时间，才会执行任务

类Executors创建线程的四种方式，主要是根据参数不同去调用ThreadPoolExecutor的构造方法：

1、public static ExecutorService newFixedThreadPool(int nThreads) 定长线程池：

可控制线程最大并发数（同时执行的线程数）
超出的线程会在队列中等待创建可容纳固定数量线程的池子，每隔线程的存活时间是无限的，当池子满了就不在添加线程了；如果池中的所有线程均在繁忙状态，对于新任务会进入阻塞队列中(无界的阻塞队列)，但是，在线程池空闲时，即线程池中没有可运行任务时，它不会释放工作线程，还会占用一定的系统资源。

适用：执行长期的任务，性能好很多

2、public static ExecutorService newCachedThreadPool() 可缓存线程池：

线程数无限制
有空闲线程则复用空闲线程，若无空闲线程则新建线程
一定程序减少频繁创建/销毁线程，减少系统开销

当有新任务到来，则插入到SynchronousQueue中，由于SynchronousQueue是同步队列，因此会在池中寻找可用线程来执行，若有可以线程则执行，若没有可用线程则创建一个线程来执行该任务；若池中线程空闲时间超过指定大小，则该线程会被销毁。

适用：执行很多短期异步的小程序或者负载较轻的服务器

3、 public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize)

支持定时及周期性任务执行。
创建一个固定大小的线程池，线程池内线程存活时间无限制，线程池可以支持定时及周期性任务执行，如果所有线程均处于繁忙状态，对于新任务会进入DelayedWorkQueue队列中，这是一种按照超时时间排序的队列结构

适用：周期性执行任务的场景

4、 public static ScheduledExecutorService newSingleThreadScheduledExecutor()单线程化的线程池：

有且仅有一个工作线程执行任务
所有任务按照指定顺序执行，即遵循队列的入队出队规则

创建只有一个线程的线程池，且线程的存活时间是无限的；当该线程正繁忙时，对于新任务会进入阻塞队列中(无界的阻塞队列)

适用：一个任务一个任务执行的场景

代码测试：

public class MyThread extends Thread{
	public MyThread(int i){
		System.out.println("创建了一个自定义线程MyThread------" + i);
	}
	
	public void run(){
		try {
			Thread.sleep(1000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println("执行了run()方法------" + new SimpleDateFormat("yyyyMMdd HH:mm:ss").format(new Date()));
	}
}

public class MyCallable implements Callable<Object> {
	private String taskNum;
	
	public MyCallable(String taskNum) {
		this.taskNum = taskNum;
   System.out.println("创建线程--" + new SimpleDateFormat("yyyyMMdd HH:mm:ss").format(new Date()));
	}
	
	@Override
	public Object call() throws Exception {
		Thread.sleep(2000);
		return "任务" + taskNum + "--开始执行:" + new SimpleDateFormat("yyyyMMdd HH:mm:ss").format(new Date());
	}
}

public class TT {
	public static void main(String[] args) {
		//创建一个定长线程池
		ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);
		//执行线程任务（无返回值）：主线程一次性循环10次，子线程每次执行三个线程任务
		for(int i = 0; i < 10; i++){
			fixedThreadPool.execute(new MyThread(i,"fixedThreadPool"));
		}
	}
}

打印结果：

fixedThreadPool创建了一个自定义线程MyThread-0;20190319 16:14:44

fixedThreadPool创建了一个自定义线程MyThread-1;20190319 16:14:44

fixedThreadPool创建了一个自定义线程MyThread-2;20190319 16:14:44

fixedThreadPool创建了一个自定义线程MyThread-3;20190319 16:14:44

fixedThreadPool创建了一个自定义线程MyThread-4;20190319 16:14:44

fixedThreadPool创建了一个自定义线程MyThread-5;20190319 16:14:44

fixedThreadPool创建了一个自定义线程MyThread-6;20190319 16:14:44

fixedThreadPool创建了一个自定义线程MyThread-7;20190319 16:14:44

fixedThreadPool创建了一个自定义线程MyThread-8;20190319 16:14:44

fixedThreadPool创建了一个自定义线程MyThread-9;20190319 16:14:44

执行了run()方法------20190319 16:14:46

执行了run()方法------20190319 16:14:48

执行了run()方法------20190319 16:14:50

执行了run()方法------20190319 16:14:52

public class TT {
	public static void main(String[] args) {
		//创建可缓存的线程池，池中的最大线程数是Integer.MAX_VALUE，即2的31次方减1，即2147483647
		ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
		for(int i = 0; i < 10; i++){
			cachedThreadPool.execute(new MyThread(i,"cachedThreadPool"));
		}
	}
}

打印结果：

cachedThreadPool创建了一个自定义线程MyThread-0;20190319 16:16:39

cachedThreadPool创建了一个自定义线程MyThread-1;20190319 16:16:39

cachedThreadPool创建了一个自定义线程MyThread-2;20190319 16:16:39

cachedThreadPool创建了一个自定义线程MyThread-3;20190319 16:16:39

cachedThreadPool创建了一个自定义线程MyThread-4;20190319 16:16:39

cachedThreadPool创建了一个自定义线程MyThread-5;20190319 16:16:39

cachedThreadPool创建了一个自定义线程MyThread-6;20190319 16:16:39

cachedThreadPool创建了一个自定义线程MyThread-7;20190319 16:16:39

cachedThreadPool创建了一个自定义线程MyThread-8;20190319 16:16:39

cachedThreadPool创建了一个自定义线程MyThread-9;20190319 16:16:39

执行了run()方法------20190319 16:16:41

public class TT {
	public static void main(String[] args) {
		//创建定期的线程池
//		主线程一次性循环4次，子线程每次执行4个线程任务。创建线程之后的1秒开始执行run()方法，以后每4秒执行一次
		ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(4);
		for(int i = 0; i < 4; i++){
//			scheduledThreadPool.execute(new MyThread(i,"scheduledThreadPool"));
			scheduledThreadPool.scheduleAtFixedRate(new MyThread(i,"scheduledThreadPool"), 1, 4, TimeUnit.SECONDS);
		}			
	}
}

打印结果：

scheduledThreadPool创建了一个自定义线程MyThread-0;20190319 16:27:46

scheduledThreadPool创建了一个自定义线程MyThread-1;20190319 16:27:46

scheduledThreadPool创建了一个自定义线程MyThread-2;20190319 16:27:46

scheduledThreadPool创建了一个自定义线程MyThread-3;20190319 16:27:46

执行了run()方法------20190319 16:27:49

执行了run()方法------20190319 16:27:53

执行了run()方法------20190319 16:27:57

public class TT {
	public static void main(String[] args) {
		//创建单个线程池
		ExecutorService singleThreadPool = Executors.newSingleThreadExecutor();
		for(int i = 0; i < 10; i++){
			singleThreadPool.execute(new MyThread(i,"singleThreadPool"));
	}	
	}
}

singleThreadPool创建了一个自定义线程MyThread-0;20190319 16:29:25

singleThreadPool创建了一个自定义线程MyThread-1;20190319 16:29:25

singleThreadPool创建了一个自定义线程MyThread-2;20190319 16:29:25

singleThreadPool创建了一个自定义线程MyThread-3;20190319 16:29:25

singleThreadPool创建了一个自定义线程MyThread-4;20190319 16:29:25

singleThreadPool创建了一个自定义线程MyThread-5;20190319 16:29:25

singleThreadPool创建了一个自定义线程MyThread-6;20190319 16:29:25

singleThreadPool创建了一个自定义线程MyThread-7;20190319 16:29:25

singleThreadPool创建了一个自定义线程MyThread-8;20190319 16:29:25

singleThreadPool创建了一个自定义线程MyThread-9;20190319 16:29:25

执行了run()方法------20190319 16:29:27

执行了run()方法------20190319 16:29:29

执行了run()方法------20190319 16:29:31

执行了run()方法------20190319 16:29:33

执行了run()方法------20190319 16:29:35

执行了run()方法------20190319 16:29:37

public class TT {
	public static void main(String[] args) throws InterruptedException, ExecutionException {
		//创建一个定长线程池
				ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);
		//执行线程任务（有返回值）：主线程一次性循环10次，子线程每次执行三个线程任务
				//创建多个有返回值的任务
				List<Future> list = new ArrayList<Future>();
				for(int i = 0; i < 10; i++){
					MyCallable c = new MyCallable(i + "");
					Future<Object> f = fixedThreadPool.submit(c);
					list.add(f);
				}
						
				//获取所有并发任务的运行结果
				for(Future future : list){
					System.out.println(future.get().toString());
				}
	}
}

打印结果：

创建线程--20190319 17:45:48

任务0--开始执行:20190319 17:45:50

任务1--开始执行:20190319 17:45:50

任务2--开始执行:20190319 17:45:50

任务3--开始执行:20190319 17:45:52

任务4--开始执行:20190319 17:45:52

任务5--开始执行:20190319 17:45:52

任务6--开始执行:20190319 17:45:54

任务7--开始执行:20190319 17:45:54

任务8--开始执行:20190319 17:45:54

任务9--开始执行:20190319 17:45:56

值得注意的是，假如要获取返回值的话，需所有线程执行完成之后，主线程才会继续往下走：

public class TT {
	public static void main(String[] args) throws InterruptedException, ExecutionException {
		//创建一个定长线程池
				ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);
		//执行线程任务（有返回值）：主线程一次性循环10次，子线程每次执行三个线程任务
				//创建多个有返回值的任务
				List<Future> list = new ArrayList<Future>();
				for(int i = 0; i < 10; i++){
					MyCallable c = new MyCallable(i + "");
					Future<Object> f = fixedThreadPool.submit(c);
					list.add(f);
				}
						
				//获取所有并发任务的运行结果
				for(Future future : list){
					System.out.println(future.get().toString());
				}
				
				//创建可缓存的线程池
				ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
				for(int i = 0; i < 10; i++){
					cachedThreadPool.execute(new MyThread(i,"cachedThreadPool"));
				}
	}
}

打印结果：

创建线程--20190319 16:49:03

任务0--开始执行:20190319 16:49:05

任务1--开始执行:20190319 16:49:05

任务2--开始执行:20190319 16:49:05

任务3--开始执行:20190319 16:49:07

任务4--开始执行:20190319 16:49:07

任务5--开始执行:20190319 16:49:07

任务6--开始执行:20190319 16:49:09

任务7--开始执行:20190319 16:49:09

任务8--开始执行:20190319 16:49:09

任务9--开始执行:20190319 16:49:11