java延时线程,一种简单的Java延迟处理器

最近做一个新项目时，有这么一个场景：使用TDDL数据库分库分表，且按SQL读写分离。在为系统做缓存层时，考虑到并发读写，可能会出现这么个问题：

缓存未设置或已过期时，写数据，主库已完成但未拉起缓存，从库也未完成同步，此时有查询请求，将会访问到从库，把旧值查询出来，如果此时写数据线程已经用最新数据拉起缓存，那读数据线程将会用旧值将缓存覆盖，导致缓存与数据库不一致，在缓存失效或下次修改之前，缓存数据将一直是过期的。

这种情况虽然比较少见，但还是有一定概率出现的。为了屏蔽主从同步可能带来的问题，一种比较简单的解决方法是延迟更新缓存，给数据库一定时间完成同步再进行缓存设置，这样就能保证最后缓存的是新数据。当然这种方案只能解决数据库同步延迟不大的普通情况。

如果是一些读多写少的数据，也可以在修改完成改一遍缓存，再放到延迟任务改一遍。

为此实现了一个简单的延迟任务处理器，主要思路是将任务放入DelayQueue，由一个专用线程从DelayQueue中取出到期的任务，放入执行线程池中执行。整体比较简单。

import com.google.common.util.concurrent.ThreadFactoryBuilder;

import java.lang.Thread.UncaughtExceptionHandler;

import java.util.List;

import java.util.concurrent.DelayQueue;

import java.util.concurrent.Delayed;

import java.util.concurrent.LinkedBlockingQueue;

import java.util.concurrent.ThreadPoolExecutor;

import java.util.concurrent.TimeUnit;

import org.apache.commons.collections.CollectionUtils;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.springframework.beans.factory.DisposableBean;

import org.springframework.beans.factory.InitializingBean;

/**

* 延迟任务处理器

* @author jerryli

* @date 2018/3/27

*/

public class DelayedTaskExecutor implements InitializingBean, DisposableBean{

private static final Logger logger = LoggerFactory.getLogger(DelayedTaskExecutor.class);

private String name;

private ThreadPoolExecutor executor;

private volatile boolean running;

private ThreadPoolExecutor putExecutor ;

private DelayQueue delayQueue = new DelayQueue<>();

public DelayedTaskExecutor(String name){

this.name = name;

}

public void submit(Runnable runnable, long delayedTime){

Task task = new Task(runnable,delayedTime);

delayQueue.offer(task);

logger.info("{}添加延迟任务 {} 延迟{}ms",this.name,task,delayedTime);

}

@Override

public void destroy() throws Exception {

running = false;

if(putExecutor != null){

putExecutor.shutdown();

boolean shutdown = putExecutor.awaitTermination(8000, TimeUnit.MILLISECONDS);

if(!shutdown){

List notRunList = putExecutor.shutdownNow();

if(CollectionUtils.isNotEmpty(notRunList)){

logger.warn("强制关闭延迟任务转移线程...未执行任务数量{}",notRunList.size());

}

}

}

if(executor != null){

executor.shutdown();

boolean shutdown = executor.awaitTermination(8000, TimeUnit.MILLISECONDS);

if(!shutdown){

List notRunList = executor.shutdownNow();

if(CollectionUtils.isNotEmpty(notRunList)){

logger.warn("强制关闭延迟任务执行线程池...未执行任务数量{}",notRunList.size());

}

}

}

}

@Override

public void afterPropertiesSet() throws Exception {

running = true;

executor = new ThreadPoolExecutor(Runtime.getRuntime().availableProcessors() + 1,

Runtime.getRuntime().availableProcessors() * 2,0,TimeUnit.MILLISECONDS, new LinkedBlockingQueue<>(),

new ThreadFactoryBuilder()

.setNameFormat(this.name + "-pool-%d")

.setUncaughtExceptionHandler(new UncaughtExceptionHandler() {

@Override

public void uncaughtException(Thread t, Throwable e) {

logger.error("延迟任务执行线程异常,thread={}",t,e);

}

})

.build());

putExecutor = new ThreadPoolExecutor(1,1,0,TimeUnit.MILLISECONDS, new LinkedBlockingQueue<>(),

new ThreadFactoryBuilder()

.setNameFormat(this.name + "-submiter")

.setUncaughtExceptionHandler(new UncaughtExceptionHandler() {

@Override

public void uncaughtException(Thread t, Throwable e) {

logger.error("延迟任务转移线程异常,thread={}",t,e);

}

})

.build());

putExecutor.execute(new Runnable() {

@Override

public void run() {

while(running || delayQueue.size() > 0){

try {

Task task = delayQueue.poll(1000, TimeUnit.MILLISECONDS);

if(task == null){

continue;

}

logger.info("开始执行延迟任务 {}",task);

executor.execute(task.getRunnable());

} catch (InterruptedException e) {

logger.error("延迟任务转移线程异常interrupted",e);

} catch (Throwable e){

logger.error("延迟任务转移线程异常",e);

}

}

logger.info("延迟任务转移线程退出");

}

});

}

class Task implements Delayed{

// 提交时间

private long submitTime;

private long runningTime;

private Runnable runnable;

Task(Runnable runnable,long delayTime){

this.runnable = runnable;

this.submitTime = System.currentTimeMillis();

this.runningTime = submitTime + delayTime;

}

@Override

public long getDelay(TimeUnit unit) {

return unit.convert(runningTime - System.currentTimeMillis(), TimeUnit.MILLISECONDS);

}

@Override

public int compareTo(Delayed o) {

if(o == null || !(o instanceof Task)){

return 1;

}

if(o == this){

return 0;

}

Task otherTask = (Task) o;

if(this.runningTime > otherTask.runningTime){

return 1;

}else if(this.runningTime == otherTask.runningTime){

return 0;

}else{

return -1;

}

}

public Runnable getRunnable() {

return runnable;

}

}

}

测试代码：

public static void main(String[] args) throws Exception {

// 使用Spring可不用调用afterPropertiesSet和destroy方法

DelayedTaskExecutor delayedTaskExecutor = new DelayedTaskExecutor("cache-delay");

delayedTaskExecutor.afterPropertiesSet();

delayedTaskExecutor.submit(() -> System.out.println("hello"), 2000);

delayedTaskExecutor.destroy();

}