Android 定时任务的多种实现方式
2016年05月22日 20:51:41 痕迹天涯119 阅读数:63920
版权声明:本文为博主原创文章,未经博主允许不得转载。 https://blog.csdn.net/u014492609/article/details/51475254
定时任务实现总结
在Android中这算是一个常用的功能了,,有兴趣一起来探讨下可以
Android消息机制
首先来了解一下Android的消息处理机制
即Handlerd的运行机制,handler的运行需要底层的MessageQueue和Looper的支撑。MessageQueue(消息队列),它的内部存储了一些消息,以队列的形式对外提供插入和删除的操作(实际为单链表存储)。Looper(消息循环),配合MessageQueue实现实现消息的不断入队和出队工作。
一个关系图:
通过Handler可以很容易将任务切换到其他线程中执行,以减少主线程的负担,因此Handler常用来进行UI更新。这里只是简单的进行一些概述。对应handler还不清楚的强烈建议参考以下博客:
Android 异步消息处理机制
Android AsyncTask完全解析
当然,现在已经有更好的消息处理办法了,了解handler和Asynctask可以更好的理解Android内部消息的处理机制。
推荐:EventBus,高度解耦,代码简洁明了,有兴趣的可以自行参考使用。
1.采用Handle与线程的sleep(long)方法
1) 定义一个Handler类,用于处理接受到的Message。
Handler handler = new Handler() {
public void handleMessage(Message msg) {
// 要做的事情
super.handleMessage(msg);
}
};
2) 新建一个实现Runnable接口的线程类,如下:
public class MyThread implements Runnable {
@Override
public void run() {
// TODO Auto-generated method stub
while (true) {
try {
Thread.sleep(10000);// 线程暂停10秒,单位毫秒
Message message = new Message();
message.what = 1;
handler.sendMessage(message);// 发送消息
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
3) 在需要启动线程的地方加入下面语句:
new Thread(new MyThread()).start();
分析:纯正的java原生实现,在sleep结束后,并不能保证竞争到cpu资源,这也就导致了时间上必定>=10000的精度问题。
2.采用Handler的postDelayed(Runnable, long)方法
1)定义一个Handler类
Handler handler=new Handler();
Runnable runnable=new Runnable() {
@Override
public void run() {
// TODO Auto-generated method stub
//要做的事情
handler.postDelayed(this, 2000);
}
};
2) 启动与关闭计时器
handler.postDelayed(runnable, 2000);//每两秒执行一次runnable.
handler.removeCallbacks(runnable);
分析:嗯,看起蛮不错,实现上也简单了,和sleep想必还不会产生阻塞,注意等待和间隔的区别。
3.采用Handler与timer及TimerTask结合的方法
1) 定义定时器、定时器任务及Handler句柄
private final Timer timer = new Timer();
private TimerTask task;
Handler handler = new Handler() {
@Override
public void handleMessage(Message msg) {
// TODO Auto-generated method stub
// 要做的事情
super.handleMessage(msg);
}
};
2) 初始化计时器任务
task = new TimerTask() {
@Override
public void run() {
// TODO Auto-generated method stub
Message message = new Message();
message.what = 1;
handler.sendMessage(message);
}
};
3) 启动和关闭定时器
timer.schedule(task, 2000, 3000);
timer.cancel();
此外,Timer也可以配合runOnUiThread实现,如下
private TimerTask mTimerTask = new TimerTask() {
@Override
public void run() {
runOnUiThread(new Runnable() {
@Override
public void run() {
//处理延时任务
}
});
}
};
分析:timer.schedule(task, 2000, 3000);
意思是在2秒后执行第一次,之后每3000秒在执行一次。timer不保证精确度且在无法唤醒cpu,不适合后台任务的定时。
采用AlarmManger实现长期精确的定时任务
AlarmManager的常用方法有三个:
- set(int type,long startTime,PendingIntent pi);//一次性
- setExact(int type, long triggerAtMillis, PendingIntent operation)//一次性的精确版
- setRepeating(int type,long startTime,long intervalTime,PendingIntent
pi);//精确重复 - setInexactRepeating(int type,long startTime,long
intervalTime,PendingIntent pi);//非精确,降低功耗
type表示闹钟类型,startTime表示闹钟第一次执行时间,long intervalTime表示间隔时间,PendingIntent表示闹钟响应动作
对以上各个参数的详细解释
闹钟的类型:
- AlarmManager.ELAPSED_REALTIME:休眠后停止,相对开机时间
- AlarmManager.ELAPSED_REALTIME_WAKEUP:休眠状态仍可唤醒cpu继续工作,相对开机时间
- AlarmManager.RTC:同1,但时间相对于绝对时间
- AlarmManager.RTC_WAKEUP:同2,但时间相对于绝对时间
- AlarmManager.POWER_OFF_WAKEUP:关机后依旧可用,相对于绝对时间
绝对时间:1970 年 1月 1 日 0 点
startTime:
闹钟的第一次执行时间,以毫秒为单位,一般使用当前时间。
- SystemClock.elapsedRealtime():系统开机至今所经历时间的毫秒数
- System.currentTimeMillis():1970 年 1 月 1 日 0 点至今所经历时间的毫秒数
intervalTime:执行时间间隔。
PendingIntent :
PendingIntent用于描述Intent及其最终的行为.,这里用于获取定时任务的执行动作。
详细参考译文:PendingIntent
利用AlarmManger+Service+BarocastReceiver实现5s一次打印操作
服务类:
public class HorizonService extends Service {
@Override
public IBinder onBind(Intent intent) {
return null;
}
@Override
public int onStartCommand(Intent intent, int flags, int startId) {
new Thread(new Runnable() {
@Override
public void run() {
Log.d("TAG", "打印时间: " + new Date().
toString());
}
}).start();
AlarmManager manager = (AlarmManager) getSystemService(ALARM_SERVICE);
int five = 5000; // 这是5s
long triggerAtTime = SystemClock.elapsedRealtime() + five;
Intent i = new Intent(this, AlarmReceiver.class);
PendingIntent pi = PendingIntent.getBroadcast(this, 0, i, 0);
manager.set(AlarmManager.ELAPSED_REALTIME_WAKEUP, triggerAtTime, pi);
return super.onStartCommand(intent, flags, startId);
}
}
广播接受器
public class AlarmReceiver extends BroadcastReceiver {
@Override
public void onReceive(Context context, Intent intent) {
Intent i = new Intent(context, HorizonService.class);
context.startService(i);
}
}
启动定时任务:
Intent intent = new Intent(this,HorizonService.class);
startService(intent);
效果Demo:
本例通过广播接收器和服务的循环调用实现了无限循环的效果,当然,你也可以直接利用setRepeating实现同样的效果。
注意:不要忘了在manifest文件中注册服务和广播接收器。
AlarmManager的取消方法:AlarmManger.cancel();
分析:该方式可唤醒cpu甚至实现精确定时,适用于配合service在后台执行一些长期的定时行为。
本文总结:不建议使用第一种方式,短期的定时任务推荐第二、三种方式实现,长期或者有精确要求的定时任务则可以配合Service在后台执行。
有其他疑问可下方提出或者直接链接官方文档AlarmService
---------------------
实现倒计时的方法
倒计时几种方法呢,这个不像正计时那样简单实现容易想到的那5种,甚至正计时通过总量减的方式全可以转化成倒计时。所以在此我想介绍另一个专门倒计时的类CountDownTimer来讲解。
构造方法:
CountDownTimer (long millisInFuture, long countDownInterval)
//millisInFuture:设置倒计时的总时间(毫秒)
//countDownInterval:设置每次减去多少毫秒
验证码获取的示例代码如下:
MainActivity.java
public class MainActivity extends AppCompatActivity {
private static final int LEFT_TIME = 999;
private static final int TIME_OVER = 998;
private Button bt_verify;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
bt_verify = (Button) findViewById(R.id.bt_verify);
bt_verify.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View view) {
setTimer();
}
});
}
private void setTimer(){
timer.start();
}
private Handler mHandler = new Handler(){
@Override
public void handleMessage(Message msg) {
super.handleMessage(msg);
switch (msg.what){
case LEFT_TIME:
long left_time = (long) msg.obj;
bt_verify.setEnabled(false);//禁止button点击
bt_verify.setText((left_time / 1000) + " S");
break;
case TIME_OVER:
bt_verify.setEnabled(true);
bt_verify.setText("点击重发");
break;
default:
break;
}
}
};
private void stopTimer(){
timer.cancel();
}
@Override
protected void onDestroy() {
super.onDestroy();
stopTimer();
}
long millisInFuture = 60*1000;
long countDownInterval =1000;
CountDownTimer timer = new CountDownTimer(millisInFuture,countDownInterval) {
@Override
public void onTick(long millisUntilFinished) {
//millisUntilFinished 剩余时间回调,这个是实时的(以countDownInterval为单位)
Message msg = Message.obtain();
msg.what = LEFT_TIME;
msg.obj = millisUntilFinished;
mHandler.sendMessage(msg);
}
@Override
public void onFinish() {
//结束时的回调
mHandler.sendEmptyMessage(TIME_OVER);
}
};
}
activity_main.xml
<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="match_parent"
android:layout_height="match_parent">
<RelativeLayout
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:layout_marginLeft="5dp"
android:layout_marginRight="5dp">
<EditText
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:layout_centerVertical="true"
android:layout_toLeftOf="@+id/bt_verify"
android:layout_marginRight="5dp"/>
<Button
android:id="@+id/bt_verify"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="获取验证码"
android:layout_alignParentRight="true"
android:layout_centerVertical="true"/>
</RelativeLayout>
</RelativeLayout>
需要注意的是:CountDownTimer如果使用不当,常常会报空指针异常,甚至造成严重的内存泄漏,不过解决办法也是有的:
一是在CountDownTimer的onTick方法中记得判空:
activity中:
if(!activity.isFinishing()){
//doing something...
}
fragment中:
if(getActivity()!=null){
//doing something...
}
二还需要在宿主Activity或fragment生命周期结束的时候,记得调用timer.cancle()方法:
@Override
public void onDestroy() {
if(timer!=null){
timer.cancel();
timer = null;
}
super.onDestroy();
}
总结:
短期的定时任务推荐用最后两种方式方式实现,长期或者有精确要求的定时任务则选择AlarmManger + Service在后台执行。最后把开始的展示图去壳之后内部实现了一遍,内容比较简单,整篇文中最值得注意的OOM问题是开发中常常忽视的,减少OOM和ANR的情况,才可以将代码的细节把控好!
如果本文对你有所帮助,请点赞!你的鼓励是我写作的最大动力!