Java并发编程14-ScheduledThreadPoolExecutor详解

最新推荐文章于 2023-08-28 13:49:04 发布

chicidao7700

最新推荐文章于 2023-08-28 13:49:04 发布

阅读量187

点赞数

文章标签： java

原文链接：https://my.oschina.net/u/3145136/blog/848079

版权

ScheduledThreadPoolExecutor继承自ThreadPoolExecutor。它主要用来在给定的延迟之后运行任务，或者定期执行任务。ScheduledThreadPoolExecutor的功能与Timer类似，但ScheduledThreadPoolExecutor功能更强大、更灵活。Timer对应的是单个后台线程，而ScheduledThreadPoolExecutor可以在构造函数中指定多个对应的后台线程数。

1 运行机制

ScheduledThreadPoolExecutor的执行示意图（本文基于JDK 6）如下图所示。

ScheduledThreadPoolExecutor为了实现周期性的执行任务，对ThreadPoolExecutor做了如下的修改。

（1）使用DelayQueue作为任务队列。

（2）获取任务的方式不同（后文会说明）。

（3）执行周期任务后，增加了额外的处理（后文会说明）。

2 实现原理

2.1 执行周期任务的过程

前面我们提到过，ScheduledThreadPoolExecutor会把待调度的任务（ScheduledFutureTask）放到一个DelayQueue中。

ScheduledFutureTask主要包含3个成员变量，如下。

（1）long型成员变量time，表示这个任务将要被执行的具体时间。

（2）long型成员变量sequenceNumber，表示这个任务被添加到ScheduledThreadPoolExecutor中的序号。

（3）long型成员变量period，表示任务执行的间隔周期。

DelayQueue封装了一个PriorityQueue，这个PriorityQueue会对队列中的ScheduledFutureTask进行排序。排序时，time小的排在前面（时间早的任务将被先执行）。如果两个ScheduledFutureTask的time相同，就比较sequenceNumber，sequenceNumber小的排在前面（也就是说，如果两个任务的执行时间相同，那么先提交的任务将被先执行）。

首先，让我们看看ScheduledThreadPoolExecutor中的线程执行周期任务的过程。下图是ScheduledThreadPoolExecutor中的线程1执行某个周期任务的4个步骤。

下面是对这4个步骤的说明。

（1）线程1从DelayQueue中获取已到期的ScheduledFutureTask（DelayQueue.take()）。到期任务是指ScheduledFutureTask的time大于等于当前时间。

（2）线程1执行这个ScheduledFutureTask。

（3）线程1修改ScheduledFutureTask的time变量为下次将要被执行的时间。

（4）线程1把这个修改time之后的ScheduledFutureTask放回DelayQueue中（DelayQueue.add()）。

2.2 take()方法的源码实现

接下来，让我们看看上面的步骤（1）获取任务的过程。下面是DelayQueue.take()方法的源代码实现。

    public E take() throws InterruptedException {
		final ReentrantLock lock = this.lock;
		lock.lockInterruptibly();// 1
		try {
			for (;;) {
				E first = q.peek();
				if (first == null) {
					available.await();// 2.1
				} else {
					long delay = first.getDelay(TimeUnit.NANOSECONDS);
					if (delay > 0) {
						long tl = available.awaitNanos(delay);// 2.2
					} else {
						E x = q.poll();// 2.3.1
						assert x != null;
						if (q.size() != 0)
							available.signalAll();// 2.3.2
						return x;
					}
				}
			}
		} finally {
			lock.unlock();// 3
		}
	}

下图是DelayQueue.take()的执行示意图。

如图所示，获取任务分为3大步骤。

（1）获取Lock。

（2）获取周期任务。

如果PriorityQueue为空，当前线程到Condition中等待；否则执行下面的2.2。

如果PriorityQueue的头元素的time时间比当前时间大，到Condition中等待到time时间；否则执行下面的2.3。

获取PriorityQueue的头元素（2.3.1）；如果PriorityQueue不为空，则唤醒在Condition中等待的所有线程（2.3.2）。

（3）释放Lock。

ScheduledThreadPoolExecutor在一个循环中执行步骤2，直到线程从PriorityQueue获取到一个元素之后（执行2.3.1之后），才会退出无限循环（结束步骤2）。

2.3 add()方法的源码实现

最后，让我们看看ScheduledThreadPoolExecutor中的线程执行任务的步骤4，把ScheduledFutureTask放入DelayQueue中的过程。下面是DelayQueue.add()的源代码实现。

    public boolean offer(E e) {
		final ReentrantLock lock = this.lock;
		lock.lock();// 1
		try {
			E first = q.peek();
			q.offer(e);// 2.1
			if (first == null || e.compareTo(first) < 0)
				available.signalAll();// 2.2
			return true;
		} finally {
			lock.unlock();// 3
		}
	}

下图是DelayQueue.add()的执行示意图。

如图所示，添加任务分为3大步骤。

（1）获取Lock。

（2）添加任务。

向PriorityQueue添加任务。

如果在上面2.1中添加的任务是PriorityQueue的头元素，唤醒在Condition中等待的所有线程。

（3）释放Lock。

3 创建方式

ScheduledThreadPoolExecutor通常使用工厂类Executors来创建。Executors可以创建2种类型的ScheduledThreadPoolExecutor，分别是包含若干个线程的ScheduledThreadPoolExecutor和只包含一个线程的SingleThreadScheduledExecutor。

3.1 ScheduledThreadPoolExecutor

下面是工厂类Executors提供的，创建固定个数线程的ScheduledThreadPoolExecutor的API。

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

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

ScheduledThreadPoolExecutor适用于需要多个后台线程执行周期任务，同时为了满足资源管理的需求而需要限制后台线程的数量的应用场景。

3.2 SingleThreadScheduledExecutor

下面是Executors提供的，创建单个线程的SingleThreadScheduledExecutor的API。

    public static ScheduledExecutorService newSingleThreadScheduledExecutor() {
        return new DelegatedScheduledExecutorService
            (new ScheduledThreadPoolExecutor(1));
    }
    public static ScheduledExecutorService newSingleThreadScheduledExecutor(ThreadFactory 
        threadFactory) {
        return new DelegatedScheduledExecutorService
            (new ScheduledThreadPoolExecutor(1, threadFactory));
    }

SingleThreadScheduledExecutor适用于需要单个后台线程执行周期任务，同时需要保证顺序地执行各个任务的应用场景。

本文节选自《Java并发编程的艺术》,版权归原作则所有！

转载于:https://my.oschina.net/u/3145136/blog/848079