Android 定时循环执行任务

一个定时循环任务的工具，可以用于执行每隔固定时间就要执行一次的任务。例如大图轮播，状态监测什么的。

共有4个Java文件。具体的使用方法在最下面。

Counter.java

package com.***.android.time;

import java.util.HashMap;

/**
* Created by zpybless on 2015/11/18.
*/
public class Counter{

static class CountableState {

int count;
}

//单例模式
private static Counter counter;
public static Counter getInstance() {
if (counter == null) {
counter = new Counter();
}
return counter;
}

private HashMap<ICountable, CountableState> states = new HashMap<ICountable, CountableState>();

//为每一个任务（使用同一个计时器）添加计数器，并启动任务instance.onCountIncreasesToOne();
//同一个TickTimer，调用多次start()的情况，计数器会增加
public void increase(ICountable instance) {

CountableState state = states.get(instance);
if (state == null) {
state = new CountableState();
state.count = 1;
states.put(instance, state);
instance.onCountIncreasesToOne();
}
else {
state.count++;
}
}

//结束任务，计数器-1，如果是最后一个线程，就结束instance.onCountDecreasesToZero();;
public void decrease(ICountable instance) {

CountableState state = states.get(instance);
state.count--;
if (state.count == 0) {
states.remove(instance);
instance.onCountDecreasesToZero();
}
}

public int getCount(ICountable instance) {
CountableState state = states.get(instance);
return state == null ? 0 : state.count;
}
}

ICountable.java

package com.***.android.time;

/**
* Created by zpybless on 2015/11/18.
*/
public interface ICountable {
void onCountIncreasesToOne();

void onCountDecreasesToZero();
}

TickTimer.java

package com.***.android.time;

import android.os.Handler;

/**
* 计时器
* Created by zpybless on 2015/11/18.
*/
public class TickTimer implements ICountable {

/**
* 计时器对外接口，每隔一段时间，执行某一任务
* @param duration 时间间隔
* @param runnable 任务进程
*/
public TickTimer(TimeSpan duration, Runnable runnable) {
this.duration = duration;
this.runnable = runnable;
}

private static int nextSessionID;

private int sessionID;

private TimeSpan duration;

private boolean isRunning;
public boolean isRunning() {
return isRunning;
}

private Runnable runnable;

private static Handler handler = new Handler();

private Runnable onTickRunnable;

//同一个TickTimer对象，对此调用此方法，onCountIncreasesToOne()只会被执行1次（第一次）
public void start() {
Counter.getInstance().increase(this);
}

public void stop() {
Counter.getInstance().decrease(this);
}

private void onTick() {

if (runnable != null) {
runnable.run();
}
}

@Override
public void onCountIncreasesToOne() {

sessionID = nextSessionID;
nextSessionID++;

onTickRunnable = new Runnable() {

public int sessionID = TickTimer.this.sessionID;

public void run() {
onTick();
if (isRunning && sessionID == TickTimer.this.sessionID) {
//再次执行本线程，使onTick()里面的线程任务达到循环执行的效果
handler.postDelayed(onTickRunnable, duration.getMilliseconds());
}
}
};

//线程开关
isRunning = true;
//启动线程
onTickRunnable.run();
}

@Override
public void onCountDecreasesToZero() {
isRunning = false;
}
}

TimeSpan.java

package com.***.android.time;

/**时间相关工具类
* Created by zpybless on 2015/11/18.
*/
public class TimeSpan {

private long milliseconds;
public long getMilliseconds() {
return milliseconds;
}

public TimeSpan(long milliseconds) {
this.milliseconds = milliseconds;
}

public int getMillisecondPart() {
return (int)(milliseconds % 1000);
}

public int getSecondPart() {
return getSecond(milliseconds);
}

public int getMinutePart() {
return getMinute(milliseconds);
}

public int getHourPart() {
return getHour(milliseconds);
}

@Override
public String toString() {
return getClockHmsString(milliseconds);
}

public static String getClockHmsString(long milliseconds) {
return String.format("%d:%02d:%02d", getHour(milliseconds), getMinute(milliseconds), getSecond(milliseconds));
}

public static String getCounterHmsString(long milliseconds) {
return String.format("%02d:%02d:%02d", getHour(milliseconds), getMinute(milliseconds), getSecond(milliseconds));
}

private static int getHour(long milliseconds) {
return (int)(Math.floor((float)milliseconds / (1000 * 60 * 60)));
}

private static int getMinute(long milliseconds) {
return (int)(Math.floor((float)milliseconds / (1000 * 60))) % 60;
}

private static int getSecond(long milliseconds) {
return (int)(Math.floor((float)milliseconds / 1000)) % 60;
}

public static TimeSpan fromMilliseconds(float time) {
return new TimeSpan((long)time);
}

public static TimeSpan fromSeconds(float time) {
return new TimeSpan((long)(time * 1000));
}

public static TimeSpan fromMinutes(float time) {
return new TimeSpan((long)(time * 1000 * 60));
}

public static TimeSpan fromHours(float time) {
return new TimeSpan((long)(time * 1000 * 60 * 60));
}

public static TimeSpan fromDays(float time) {
return new TimeSpan((long)(time * 1000 * 60 * 60 * 24));
}
}

具体使用：

TickTimer timer = new TickTimer(TimeSpan.fromSeconds(10.00f)【时间间隔】, new Runnable() {

@Override public void run() { //要执行的任务 }});timer.start();