package org.quickbundle.tools.support.buffer;
import java.util.Iterator;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.atomic.AtomicInteger;
import org.quickbundle.config.RmBaseConfig;
/**
* 刷新监视器
*
* @author liujia
* @since 2010-10-14
*/
public class FlushQueueThread extends Thread {
static enum ThreadState{
READY,
RUNNING,
SLEEPING,
SHUTTING,
SHUTTED
}
private FlushQueueThread() {
super("RM-FlushQueue");
this.setDaemon(true);
}
/**
* 刷新任务执行器
*/
private ExecutorService executor = Executors.newCachedThreadPool(new ThreadFactory() {
final ThreadGroup group;
final AtomicInteger threadNumber = new AtomicInteger(1);
final String namePrefix;
{
SecurityManager s = System.getSecurityManager();
group = (s != null)? s.getThreadGroup() : Thread.currentThread().getThreadGroup();
namePrefix = "RM-FlushQueue-thread-";
}
public Thread newThread(Runnable r) {
Thread t = new Thread(group, r, namePrefix + threadNumber.getAndIncrement(), 0);
if (t.isDaemon()) {
t.setDaemon(false);
}
if (t.getPriority() != Thread.NORM_PRIORITY) {
t.setPriority(Thread.NORM_PRIORITY);
}
return t;
}
});
/**
* 检查的缓冲器集合 为保证高效迭代查询,使用CopyOnWrite结构
*/
private CopyOnWriteArrayList<AbstractTaskQueue> bufs = new CopyOnWriteArrayList<AbstractTaskQueue>();
/**
* 获得缓冲器列表
* @return the bufs
*/
public CopyOnWriteArrayList<AbstractTaskQueue> getBufs() {
return bufs;
}
/**
* 当前状态
*/
private ThreadState thState = ThreadState.READY;
/**
* 控制线程开关
*/
private boolean stopFlag = false;
/**
* 检查周期
*/
private long flush_interval = RmBaseConfig.getSingleton().getCacheCheckInterval();
public void addTaskQueue(AbstractTaskQueue buf) {
if (buf == null) {
return;
}
bufs.add(buf);
}
/**
*
* @param forceFlush 值true时不检查,直接提交。false时检查,不一定提交
*/
private void commitFlushTasks(final boolean forceFlush){
//检查刷新全部缓冲器
Iterator<AbstractTaskQueue> it = bufs.iterator();
while (it.hasNext()) {
final AbstractTaskQueue buf = it.next();
Runnable task = new Runnable() {
public void run() {
if(forceFlush) {
buf.tryFlush();
} else {
buf.checkFlush();
}
};
};
executor.execute(task);
}
}
/**
* 进入"关闭ing"状态
*/
public void shutdown(){
stopFlag = true;
thState = ThreadState.SHUTTING;
synchronized (this) {
notifyAll();
}
}
public String getThreadState(){
return thState.name();
}
/**
* 完成最终的提交,然后关闭线程池
*/
private void doFinalComplete() {
commitFlushTasks(true);
executor.shutdown();
thState = ThreadState.SHUTTED;
}
@Override
public void run() {
thState = ThreadState.SLEEPING;
while (!stopFlag) {
try {
thState=ThreadState.SLEEPING;
synchronized (this) {
wait(flush_interval);
}
} catch (InterruptedException e) {
//记录已中断处理过
Thread.interrupted();
doFinalComplete();
break;
}
thState = ThreadState.RUNNING;
commitFlushTasks(false);
}
doFinalComplete();
}
/**
* 全局单例对象
*/
static FlushQueueThread _flushThread = new FlushQueueThread();
public static FlushQueueThread getSingleton() {
return _flushThread;
}
static { //类载入的时候,启动本线程
if (!_flushThread.isAlive()) {
synchronized (_flushThread) {
if (!_flushThread.isAlive()) {
_flushThread.start();
}
}
}
}
}