一个简单的延时运行“环”

前几天看了片文章介绍了，延迟运行“环”，所以自己实现了一下，图示：

 

 

public abstract class TaskNode {
	/**
	 * 旋转几圈后执行
	 */
	private int CycleNum;
	
	public abstract void doFunction();

	public int getCycleNum() {
		return CycleNum;
	}

	public void setCycleNum(int cycleNum) {
		CycleNum = cycleNum;
	}
	
	
	
	
	
}

 

import java.util.ArrayList;
import java.util.List;

import javax.management.timer.Timer;


public class Test {
	
	private int por;
	
	private int sum=3600;

	/**
	 * 环状结构
	 */
	private Object[] loop= new Object[sum];
	
	
	public void putTask(TaskNode t, int s){
		//计算第几圈执行
		int num= Integer.valueOf((int) Math.floor(s/sum));
		t.setCycleNum(num);
		int tag = s%sum;
		if(loop[tag]!=null){
			List<TaskNode> list = (List<TaskNode>)loop[tag];
			list.add(t);
		}else{
			List<TaskNode> list = new ArrayList<TaskNode>();
			list.add(t);
			loop[tag]=list;
		}
	}
	
	 
	public List<TaskNode> getTask(int i){
		if(loop[i]==null){
			return null;
		}
		List<TaskNode> list = (List<TaskNode>)loop[i];
		if(list.size()==0){
			return null;
		}
		return list;
	}
	
	public void work(){
		if(this.getTask(por)==null){
			return;
		}
		List<TaskNode> list=this.getTask(por);
		for(int i=0;i<list.size(); i++){
			TaskNode t = list.get(i);
			int num = t.getCycleNum();
			if(num==0){
				t.doFunction();
				list.remove(i);
			}else{
				t.setCycleNum(num-1);
			}
		}
		
	}
	
	public static void main(String[] args) {
		final Test t = new Test();
		
		t.putTask(new testNode("我32秒钟执行！！"), 32);
		t.putTask(new testNode("我79秒钟执行！！"), 79);
		t.putTask(new testNode("我144秒钟执行！！"), 144);
		t.putTask(new testNode("我190秒钟执行！！"), 190);
		t.por=0;
		Runnable r=new Runnable() {
			
			@Override
			public void run() {
				while(true){
					t.work();
					t.por++;
					System.out.println("秒："+t.por);
					if(t.por>t.sum-1){
						t.por=0;
					}
					try {
						Thread.sleep(1000);
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
				}
				
			}
		};
		new Thread(r).start();
	}
	

}

 

这种形式有个弊端，必须要保证任务1秒钟执行完，所以可用性还得具体场景，具体分析