大家好，又见面了，我是你们的朋友全栈君。如果您正在找激活码,请点击查看最新教程,关注关注公众号 “全栈程序员社区” 获取激活教程,可能之前旧版本教程已经失效.最新Idea2022.1教程亲测有效,一键激活。
Jetbrains全系列IDE使用 1年只要46元 售后保障 童叟无欺
好用的定时器封装工具类，谁用谁知道，代码仅供学习参考。
import java.util.HashMap;
import java.util.LinkedList;
import java.util.Map;
import java.util.Queue;
import com.tcl.framework.log.NLog;
import android.os.Handler;
import android.os.HandlerThread;
import android.os.Looper;
import android.os.Message;
public class IoTimer {
public static final int INVALID_TIMER_ID = -1;
private static final int BASE_MSG_ID = 100;
private static volatile IoTimer sTimer = null;
private static final Object slock = new Object();
private TimerHandler mTimerHandler;
private Handler mIoHandler;
private int mBaseTimerId = 1;
private Map<Integer, TimerTask> mTimersList;
private Queue<Integer> mValidIdList = null;
private Looper mIoLooper = null;
private volatile boolean mInited = false;
public static IoTimer shareTimer()
{
if (sTimer == null) {
synchronized (slock) {
if (sTimer == null) {
sTimer = new IoTimer();
sTimer.init();
}
}
}
return sTimer;
}
public static void destroyTimer()
{
if (sTimer != null) {
synchronized (slock) {
final IoTimer timer = sTimer;
if (timer != null)
timer.destroy();
sTimer = null;
}
}
}
private class TimerTask
{
Runnable action;
int id;
int loopCount;
long expiredTimeout;
void loop()
{
if (loopCount == 0 || loopCount == 1) {
remove(id);
}
else if (loopCount > 1)
loopCount –;
Message msg = mTimerHandler.obtainMessage(messageIdFromTimerId(id), this);
mTimerHandler.sendMessageDelayed(msg, expiredTimeout);
}
void disable()
{
loopCount = 0;
action = null;
mTimerHandler.removeMessages(messageIdFromTimerId(id));
}
}
private IoTimer() {
mTimersList = new HashMap<Integer, IoTimer.TimerTask>();
mValidIdList = new LinkedList<Integer>();
}
private void init() {
if (mInited)
return;
HandlerThread thread = new HandlerThread(“io_timer”) {
@Override
protected void onLooperPrepared() {
mIoLooper = getLooper();
mTimerHandler = new TimerHandler(mIoLooper);
mIoHandler = new Handler(mIoLooper);
mInited = true;
synchronized (IoTimer.this) {
IoTimer.this.notify();
}
}
};
thread.start();
waitToPrepared();
}
private void waitToPrepared() {
synchronized (this) {
while (!mInited) {
try {
wait(10);
} catch (InterruptedException e) {
break;
}
}
}
}
private void destroy() {
if (!mInited)
return;
clear();
mInited = false;
mIoLooper.quit();
}
public boolean resetTimer(int tid, long timeout)
{
TimerTask task = null;
synchronized (this) {
task = mTimersList.get(tid);
}
if (task == null)
return false;
int mid = messageIdFromTimerId(tid);
mTimerHandler.removeMessages(mid);
task.expiredTimeout = timeout;
Message msg = mTimerHandler.obtainMessage(mid, task);
mTimerHandler.sendMessageDelayed(msg, task.expiredTimeout);
return true;
}
public boolean resetTimer(int tid)
{
if (!mInited)
throw new IllegalStateException(“not inited”);
TimerTask task = null;
synchronized (this) {
task = mTimersList.get(tid);
}
if (task == null)
return false;
int mid = messageIdFromTimerId(tid);
mTimerHandler.removeMessages(mid);
Message msg = mTimerHandler.obtainMessage(mid, task);
mTimerHandler.sendMessageDelayed(msg, task.expiredTimeout);
return true;
}
public int scheduleTimer(long timeout, Runnable action)
{
return scheduleTimer(timeout, action, 1, timeout);
}
public int scheduleTimer(long timeout, Runnable action, int loop, long delay) {
if (timeout < 0 || action == null || loop == 0)
throw new IllegalArgumentException(“timeout is invalid, or action is null, or loop is 0!”);
if (!mInited)
throw new IllegalStateException(“not inited”);
int id = nextTimerId();
if (id == -1) {
return INVALID_TIMER_ID;
}
TimerTask tt = new TimerTask();
tt.id = id;
tt.expiredTimeout = timeout;
tt.action = action;
tt.loopCount = loop;
synchronized (this) {
mTimersList.put(id, tt);
}
Message msg = mTimerHandler.obtainMessage(messageIdFromTimerId(id), tt);
mTimerHandler.sendMessageDelayed(msg, delay);
return id;
}
private synchronized TimerTask remove(int tid)
{
TimerTask ret = null;
ret = mTimersList.remove(tid);
if (!mValidIdList.contains(tid)) {
if (!mValidIdList.offer(tid)){
NLog.e(“TimerTask”, “offer fail”);
}
}
return ret;
}
private synchronized boolean hasTimer(int tid)
{
return mTimersList.containsKey(tid);
}
public void cancelTimer(int tid)
{
TimerTask task = remove(tid);
if (task == null)
return;
task.disable();
}
public synchronized void clear()
{
mValidIdList.clear();
mTimersList.clear();
mBaseTimerId = 1;
}
protected synchronized int nextTimerId() {
if (mValidIdList.size() == 0)
return mBaseTimerId++;
int id = mValidIdList.poll();
return id;
}
private int messageIdFromTimerId(int id)
{
return (BASE_MSG_ID + id);
}
protected void onTimer(TimerTask task) {
final Runnable action = task.action;
if (action != null) {
action.run();
}
}
class TimerHandler extends Handler
{
public TimerHandler(Looper looper) {
super(looper);
}
@Override
public void handleMessage(Message msg) {
if (msg.what < BASE_MSG_ID)
return;
TimerTask task = (TimerTask) msg.obj;
if (hasTimer(task.id)) {
mIoHandler.post(new TimerRunnable(task));
task.loop();
}
}
}
private class TimerRunnable implements Runnable
{
final TimerTask task;
public TimerRunnable(final TimerTask tt) {
this.task = tt;
}
@Override
public void run() {
onTimer(task);
}
}
}
发布者：全栈程序员-站长，转载请注明出处：https://javaforall.net/160037.html原文链接：https://javaforall.net
