9.jdk多任务执行框架

最新推荐文章于 2023-09-11 01:18:39 发布

原创最新推荐文章于 2023-09-11 01:18:39 发布 · 383 阅读

0 ·

CC 4.0 BY-SA版权

java并发、多线程相关专栏收录该内容

14 篇文章

订阅专栏

本文详细介绍如何利用Java的Executor框架创建自定义线程池，包括固定数量线程池、单一线程线程池及可伸缩线程池等，并探讨了线程池的核心参数配置、任务队列类型选择及拒绝策略实现。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

文章目录

博客概述
特定功能的线程池
底层代码实现
ThreadPoolExecutor
演示第四种线程池
自定义线程池使用详解

博客概述

为了更好的控制多线程，jdk提供了一套线程框架Executor，帮助开发人员有效地进行线程控制。他们都在java.util.concurrent包中，是jdk并发包的核心。其中有一个比较重要的类：Executors，他扮演线程工厂的角色，我们通过Executors可以创建特定功能的线程池。

特定功能的线程池

第一个：固定数量线程池。其他的创建方法类似。如果10个线程，有第11个任务来了，会把11个任务缓存到任务队列中。等到线程有一个忙完了，会处理第11个任务。
第二个：单一线程线程池，理解为第一种线程的定制版。
第一个第二个线程池，任务队列无限长，都是linkedblockingqueue。
第三个：不定长线程池，来多少任务，起多少线程，处理任务期间有线程完成了，会空闲下来，等待60S，60s中有任务来了，他就顶上去处理。如果60s过了，没有任务，这个线程就销毁。如果所有线程都在工作的时候，来了新任务，就启动新的线程去处理。实时性很高，但是对机器要求也高。
第四个：四个静态方法，最后一个比较类似于Timer。可以固定线程的数量。
在这里插入图片描述

底层代码实现

对于单线程线程池和固定数量线程池，底层都是一个对象的不同参数构造函数实现的。任务队列只阻塞队列（无限长度）。

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

对于可伸缩的线程池，底层代码实现如下，使用了sync队列，意味着是不存储任务的，来了任务就让线程执行，没有线程就新建，导致对机器性能要求高。

 return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                      60L, TimeUnit.SECONDS,
                                      new SynchronousQueue<Runnable>());

对于定时任务线程池，底层任务队列是延迟队列，以此来实现定时任务的效果。

public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
        return new ScheduledThreadPoolExecutor(corePoolSize);
    }

看一下ScheduledThreadPoolExecutor的实现是什么：

 public ScheduledThreadPoolExecutor(int corePoolSize) {
        super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,
              new DelayedWorkQueue());
    }

看一下他的父类：

public class ScheduledThreadPoolExecutor
        extends ThreadPoolExecutor
        implements ScheduledExecutorService {

也就是说四个静态方法提供的线程池，都是一个对象的不同构造函数设置实现的。这个对象就是：
ThreadPoolExecutor。我们可以直接使用这个来自定义线程池。

ThreadPoolExecutor

要实现自定义线程池，主要是对ThreadPoolExecutor的参数进行配置。
在这里插入图片描述
核心线程数（初始化时），
最大线程数，
空闲时间，
时间单位，
自己制定的任务队列（存放来不及处理的任务）（联系那个公路项目三种队列的选择），
自定义线程工厂（创建什么样的线程），
拒绝执行的策略（队列被填满时的处理）（联系那个公路项目拒绝策略）。

演示第四种线程池

代码参数解释：
command：要执行的任务
1：初始化时间，第一次执行的时间
5：轮询时间
TimeUnit：最后是时间单位。

import java.util.concurrent.Executors;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.TimeUnit;

class Temp extends Thread {
    public void run() {
        System.out.println("run");
    }
}

public class ScheduledJob {
	
    public static void main(String args[]) throws Exception {
    
    	Temp command = new Temp();
        ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1);
        
        ScheduledFuture<?> scheduleTask = scheduler.scheduleWithFixedDelay(command, 5, 1, TimeUnit.SECONDS);
    
    }
}

自定义线程池使用详解

构造方法中的队列类型很关键。

有界队列，若有新的任务需要执行，如果线程池的实际线程数小于corePoolSize，则优先创建线程，若大于corePoolSize，则会将任务加入任务队列，若队列已满，则在总线程数不大于maxPoolSize的前提下，创建新的线程，若线程数大于maxPoolSize，则执行拒绝策略。或者其他的自定义方式。
无界的任务队列，LinkedBlockingQueue，与有界队列相比，除非系统资源耗尽，否则无界的任务队列不存在任务入队失败的情况。当有新任务到来的时候，系统的线程数小于corePoolSize，则会创建线程执行任务。当达到poolsize之后，就不会继续增加线程。若后续仍有新的任务加入，而没有空闲的线程资源，则任务直接进入队列等待。若任务处理和创建的速度差异很大，无界队列会快速保持增长，直到耗尽系统内存。
特别注意：对于无界队列，max这个参数没有意义，有限制的只有coresize。为啥没有意义，因为只有在任务队列满了，才会产生当前线程数与max线程数的比较，无界队列不存在满的概念，所以永远不会触发比较，所以，max参数不生效。

队列满了之后的jdk的拒绝策略如下：

AbortPolicy：直接抛出异常，组织系统正常工作。
CallerRunsPolicy：只要线程池未关闭，该策略直接在调用者线程中，运行当前被丢弃的任务。
DiscardOldestPolicy：丢弃最老的一个请求，尝试再次提交当前任务。
DiscardPolicy：丢弃无法处理的任务，不给予任何处理。
如果需要自定义拒绝策略可以实现RejectedExecutionHandler接口。

基于有界队列的自定义线程池代码示例

主函数

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.ThreadPoolExecutor.DiscardOldestPolicy;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.ThreadPoolExecutor.CallerRunsPolicy;



public class UseThreadPoolExecutor1 {


	public static void main(String[] args) {
		/**
		 * 在使用有界队列时，若有新的任务需要执行，如果线程池实际线程数小于corePoolSize，则优先创建线程，
		 * 若大于corePoolSize，则会将任务加入队列，
		 * 若队列已满，则在总线程数不大于maximumPoolSize的前提下，创建新的线程，
		 * 若线程数大于maximumPoolSize，则执行拒绝策略。或其他自定义方式。
		 * 
		 */	
		ThreadPoolExecutor pool = new ThreadPoolExecutor(
				1, 				//coreSize
				2, 				//MaxSize
				60, 			//60
				TimeUnit.SECONDS, 
				new ArrayBlockingQueue<Runnable>(3)			//指定一种队列 （有界队列）
				//new LinkedBlockingQueue<Runnable>()
				, new MyRejected()
				//, new DiscardOldestPolicy() 
				);
		
		MyTask mt1 = new MyTask(1, "任务1");
		MyTask mt2 = new MyTask(2, "任务2");
		MyTask mt3 = new MyTask(3, "任务3");
		MyTask mt4 = new MyTask(4, "任务4");
		MyTask mt5 = new MyTask(5, "任务5");
		MyTask mt6 = new MyTask(6, "任务6");
		
		pool.execute(mt1);
		pool.execute(mt2);
		pool.execute(mt3);
		pool.execute(mt4);
		pool.execute(mt5);
		pool.execute(mt6);
		
		pool.shutdown();
		
	}
}

Task任务

public class MyTask implements Runnable {

	private int taskId;
	private String taskName;
	
	public MyTask(int taskId, String taskName){
		this.taskId = taskId;
		this.taskName = taskName;
	}
	
	public int getTaskId() {
		return taskId;
	}

	public void setTaskId(int taskId) {
		this.taskId = taskId;
	}

	public String getTaskName() {
		return taskName;
	}

	public void setTaskName(String taskName) {
		this.taskName = taskName;
	}

	@Override
	public void run() {
		try {
			System.out.println("run taskId =" + this.taskId);
			Thread.sleep(5*1000);
			//System.out.println("end taskId =" + this.taskId);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}		
	}
	
	public String toString(){
		return Integer.toString(this.taskId);
	}

}

代码执行解析：

先执行一个任务。
会看到马上打印，因为初始化就有一个线程，正好来一个任务，干完活（5S之后）线程停止。
然后5秒后线程停止。
shutdown方法是等线程执行完了之后停止。
再执行两个任务。
第二个任务会被加入队列。
10S后线程池才停止。
一个线程执行两个任务。
三个任务四个任务，同理。
都是一个线程去做。
此时属于一个初始化线程在运行，队列未满（任务数量>3不成立）。
当执行5个任务，线程执行一个，队列里放三个。
第五个会让第二个线程执行。
也就是15秒执行完毕。
第一个五秒：两个线程分别干掉一个任务，剩下三个任务。
第二个五秒：两个线程分别干掉一个任务，剩下1个任务。
第三个五秒：剩下的一个任务被一个线程处理。剩下0个任务。
总计用时15S。
如果是6个任务，就会抛出异常。因为此时两个线程都在工作（最大线程数满了），队列里有三个任务满负载（任务队列满了），没有地方放第六个任务，就报错了。

基于无界队列的自定义线程池代码示例

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;

public class UseThreadPoolExecutor2 implements Runnable{

	private static AtomicInteger count = new AtomicInteger(0);
	//里面用了原子类，就可以不加锁了
	@Override
	public void run() {
		try {
			int temp = count.incrementAndGet();
			System.out.println("任务" + temp);
			Thread.sleep(2000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
	
	public static void main(String[] args) throws Exception{
		//System.out.println(Runtime.getRuntime().availableProcessors()); 获得电脑的核心数
		BlockingQueue<Runnable> queue = 
				new LinkedBlockingQueue<Runnable>();
				//new ArrayBlockingQueue<Runnable>(10);
		ExecutorService executor  = new ThreadPoolExecutor(
					5, 		//core
					10, 	//max
					120L, 	//2fenzhong
					TimeUnit.SECONDS,
					queue);
		
		for(int i = 0 ; i < 20; i++){
			executor.execute(new UseThreadPoolExecutor2());
		}
		Thread.sleep(1000);
		System.out.println("queue size:" + queue.size());		//10
		Thread.sleep(2000);
	}


}

这种无界队列，放入多少任务都不会报错，只会耗尽电脑资源。如果是有界队列的话，放入的任务的数量大于max线程数+队列长度的话就会报错了。

丢弃策略详解

坦白说jdk自带的这四种策略都非常操蛋，原因很简单，丢数据的现象是不容忍的。四种策略概述：

抛异常
要被丢弃的任务先执行。
丢弃最老的请求，尝试再次直接当前任务（后来的插队执行）。
丢弃放不进去的任务。
我们对于这种丢弃策略一般都是自定义的，需要实现一个接口：RejectedExecutionHandler

代码实现

import java.net.HttpURLConnection;
import java.util.concurrent.RejectedExecutionHandler;
import java.util.concurrent.ThreadPoolExecutor;

public class MyRejected implements RejectedExecutionHandler{

	
	public MyRejected(){
	}
	
	@Override
	public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
		System.out.println("自定义处理..");
		System.out.println("当前被拒绝任务为：" + r.toString());
		

	}

}