2. 程式人生 > >多種方式實現Android定時任務，哪一款是你的FEEL？

多種方式實現Android定時任務，哪一款是你的FEEL？

阿新 • • 發佈：2018-12-23

前言

專案中總是會因為各種需求新增各種定時任務，所以就打算小結一下Android中如何實現定時任務，下面的解決方案的案例大部分都已在實際專案中實踐，特此列出供需要的朋友參考，如果有什麼使用不當或者存在什麼問題，歡迎留言指出！直接上乾貨！

解決方案

普通執行緒sleep的方式實現定時任務

建立一個thread，然後讓它在while迴圈裡一直執行著，通過sleep方法來達到定時任務的效果，這是最常見的，可以快速簡單地實現。但是這是java中的實現方式，不建議使用

    public class ThreadTask {  
    public static void main
 
(String[] args) {  
        final long timeInterval = 1000;  
        Runnable runnable = new Runnable() {  
            public void run() {  
                while (true) {  
                    System.out.println("execute task");  
                    try {  
                        Thread.sleep(timeInterval);  
                    } catch
 
 (InterruptedException e) {  
                        e.printStackTrace();  
                    }  
                }  
            }  
        };  
        Thread thread = new Thread(runnable);  
        thread.start();  
    }  
}

Timer實現定時任務

和普通執行緒+sleep（long）+Handler的方式比，優勢在於

  • 可以控制TimerTask的啟動和取消
  • 第一次執行任務時可以指定delay的時間。

在實現時，Timer類排程任務，TimerTask則是通過在run()方法裡實現具體任務（然後通過Handler與執行緒協同工作，接收執行緒的訊息來更新主UI執行緒的內容）。

  • Timer例項可以排程多工，它是執行緒安全的。當Timer的構造器被呼叫時，它建立了一個執行緒，這個執行緒可以用來排程任務。
   /**
    * start Timer
    */
    protected synchronized void startPlayerTimer() {
        stopPlayerTimer();
        if (playTimer == null) {
            playTimer = new PlayerTimer();
            Timer m_musictask = new Timer();
            m_musictask.schedule(playTimer, 5000, 5000);
        }
    }

    /**
     * stop Timer
     */
    protected synchronized void stopPlayerTimer() {
        try {
            if (playTimer != null) {
                playTimer.cancel();
                playTimer = null;
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public class PlayerTimer extends TimerTask {

        public PlayerTimer() {
        }

        public void run() {
            //execute task
        }
    }

然而Timer是存在一些缺陷的

  • Timer在執行定時任務時只會建立一個執行緒，所以如果存在多個任務，且任務時間過長，超過了兩個任務的間隔時間，會發生一些缺陷
  • 如果Timer排程的某個TimerTask丟擲異常，Timer會停止所有任務的執行
  • Timer執行週期任務時依賴系統時間,修改系統時間容易導致任務被掛起（如果當前時間小於執行時間）

注意：

  • Android中的Timer和java中的Timer還是有區別的，但是大體呼叫方式差不多
  • Android中需要根據頁面的生命週期和顯隱來控制Timer的啟動和取消
    java中Timer：

    這裡寫圖片描述

    Android中的Timer：

    這裡寫圖片描述

ScheduledExecutorService實現定時任務

ScheduledExecutorService是從JDK1.5做為併發工具類被引進的，存在於java.util.concurrent，這是最理想的定時任務實現方式。
相比於上面兩個方法，它有以下好處：

  • 相比於Timer的單執行緒，它是通過執行緒池的方式來執行任務的，所以可以支援多個任務併發執行 ,而且彌補了上面所說的Timer的缺陷
  • 可以很靈活的去設定第一次執行任務delay時間
  • 提供了良好的約定，以便設定執行的時間間隔

簡例：

public class ScheduledExecutorServiceTask 
{  
    public static void main(String[] args) 
    {  
        final TimerTask task = new TimerTask()  
        {  
            @Override  
            public void run()  
            {  
               //execute task  
            }  
        };   
        ScheduledExecutorService pool = Executors.newScheduledThreadPool(1);  
        pool.scheduleAtFixedRate(task, 0 , 1000, TimeUnit.MILLISECONDS);  

    }  
}

實際案例背景：

  • 應用中多個頁面涉及比賽資訊展示（包括比賽狀態，比賽結果），因此需要實時更新這些資料

思路分析：

  • 多頁面多介面重新整理
    • 就是每個需要重新整理的頁面基於自身需求基於特定介面定時重新整理
    • 每個頁面要維護一個定時器，然後基於頁面的生命週期和顯隱進行定時器的開啟和關閉（保證資源合理釋放）
    • 而且這裡的重新整理涉及到是重新整理區域性資料還是整體資料，重新整理整體資料效率會比較低，顯得非常笨重
  • 多頁面單介面重新整理
    • 介面給出一組需要實時進行重新整理的比賽資料資訊，客戶端基於id進行統一過濾匹配
    • 通過單例封裝統一定時重新整理回撥介面（注意記憶體洩露的問題，頁面銷燬時關閉ScheduledExecutorService ）
    • 需要重新整理的item統一呼叫，入口唯一，方便維護管理，擴充套件性好
    • 區域性重新整理，效率高
public class PollingStateMachine implements INetCallback {

    private static volatile PollingStateMachine instance = null;
    private ScheduledExecutorService pool;
    public static final int TYPE_MATCH = 1;

    private Map matchMap = new HashMap<>();
    private List<WeakReference<View>> list = new ArrayList<>();
    private Handler handler;

    // private constructor suppresses
    private PollingStateMachine() {
        defineHandler();
        pool = Executors.newSingleThreadScheduledExecutor();
        pool.scheduleAtFixedRate(new Runnable() {
            @Override
            public void run() {
                doTasks();
            }
        }, 0, 10, TimeUnit.SECONDS);
    }

    private void doTasks() {
        ThreadPoolUtils.execute(new PollRunnable(this));
    }

    public static PollingStateMachine getInstance() {
        // if already inited, no need to get lock everytime
        if (instance == null) {
            synchronized (PollingStateMachine.class) {
                if (instance == null) {
                    instance = new PollingStateMachine();
                }
            }
        }
        return instance;
    }
    public <VIEW extends View> void subscibeMatch(VIEW view, OnViewRefreshStatus onViewRefreshStatus) {
        subscibe(TYPE_MATCH,view,onViewRefreshStatus);
    }

    private <VIEW extends View> void subscibe(int type, VIEW view, OnViewRefreshStatus onViewRefreshStatus) {
        view.setTag(onViewRefreshStatus);
        if (type == TYPE_MATCH) {
            onViewRefreshStatus.update(view, matchMap);
        } 
        for (WeakReference<View> viewSoftReference : list) {
            View textView = viewSoftReference.get();
            if (textView == view) {
                return;
            }
        }
        WeakReference<View> viewSoftReference = new WeakReference<View>(view);
        list.add(viewSoftReference);
    }

    public void updateView(final int type) {
        Iterator<WeakReference<View>> iterator = list.iterator();
        while (iterator.hasNext()) {
            WeakReference<View> next = iterator.next();
            final View view = next.get();
            if (view == null) {
                iterator.remove();
                continue;
            }
            Object tag = view.getTag();
            if (tag == null || !(tag instanceof OnViewRefreshStatus)) {
                continue;
            }
            final OnViewRefreshStatus onViewRefreshStatus = (OnViewRefreshStatus) tag;
            handler.post(new Runnable() {
                @Override
                public void run() {
                    if (type == TYPE_MATCH) {
                        onViewRefreshStatus.update(view, matchMap);
                    } 
                }
            });

        }
    }

    public void clear() {
        pool.shutdown();
        instance = null;
    }

    private Handler defineHandler() {
        if (handler == null && Looper.myLooper() == Looper.getMainLooper()) {
            handler = new Handler();
        }
        return handler;
    }


    @Override
    public void onNetCallback(int type, Map msg) {
        if (type == TYPE_MATCH) {
            matchMap=msg;
        } 
        updateView(type);
    }
}

需要重新整理的item呼叫

PollingStateMachine.getInstance().subscibeMatch(tvScore, new OnViewRefreshStatus<ScoreItem, TextView>(matchViewItem.getMatchID()) {
            @Override
            public void OnViewRefreshStatus(TextView view, ScoreItem scoreItem) {
                //重新整理處理
                }
        });

網路資料回撥介面

public interface INetCallback {

    void onNetCallback(int type,Map msg);

}

重新整理回撥介面：

public abstract class OnViewRefreshStatus<VALUE, VIEW extends View> {
    private static final String TAG = OnViewRefreshStatus.class.getSimpleName();
    private long key;

    public OnViewRefreshStatus(long key) {
        this.key = key;
    }

    public long getKey() {
        return key;
    }

    public void update(final VIEW view, Map<Long, VALUE> map) {
        final VALUE value = map.get(key);

        if (value == null) {
            return;
        }
        OnViewRefreshStatus(view, value);

    }


    public abstract void OnViewRefreshStatus(VIEW view, VALUE value);

}

Handler實現定時任務

通過Handler延遲傳送訊息的形式實現定時任務。

  • 這裡通過一個定時傳送socket心跳包的案例來介紹如何通過Handler完成定時任務

案例背景

  • 由於移動裝置的網路的複雜性，經常會出現網路斷開，如果沒有心跳包的檢測， 客戶端只會在需要傳送資料的時候才知道自己已經斷線，會延誤，甚至丟失伺服器傳送過來的資料。 所以需要提供心跳檢測

下面的程式碼只是用來說明大體實現流程

  • WebSocket初始化成功後，就準備傳送心跳包
  • 每隔30s傳送一次心跳
  • 建立的時候初始化Handler，銷燬的時候移除Handler訊息佇列
private static final long HEART_BEAT_RATE = 30 * 1000;//目前心跳檢測頻率為30s
private Handler mHandler;
private Runnable heartBeatRunnable = new Runnable() {
        @Override
        public void run() {
            // excute task
            mHandler.postDelayed(this, HEART_BEAT_RATE);
        }
    };
public void onCreate() {
     //初始化Handler
    }

//初始化成功後，就準備傳送心跳包
public void onConnected() {
        mHandler.removeCallbacks(heartBeatRunnable);
        mHandler.postDelayed(heartBeatRunnable, HEART_BEAT_RATE);
    }

public void onDestroy() {
        mHandler.removeCallbacks(heartBeatRunnable)
    }

注意：這裡開啟的runnable會在這個handler所依附執行緒中執行，如果handler是在UI執行緒中建立的，那麼postDelayed的runnable自然也依附在主執行緒中。

AlarmManager實現精確定時操作

我們使用Timer或者handler的時候會發現，delay時間並沒有那麼準。如果我們需要一個嚴格準時的定時操作，那麼就要用到AlarmManager，AlarmManager物件配合Intent使用，可以定時的開啟一個Activity,傳送一個BroadCast,或者開啟一個Service.

案例背景

  • 在比賽開始前半個小時本地定時推送關注比賽的提醒資訊

AndroidManifest.xml中宣告一個全域性廣播接收器

  <receiver
            android:name=".receiver.AlarmReceiver"
            android:exported="false">
            <intent-filter>
                <action android:name="${applicationId}.BROADCAST_ALARM" />
            </intent-filter>
        </receiver>

接收到action為IntentConst.Action.matchRemind的廣播就展示比賽
提醒的Notification

public class AlarmReceiver extends BroadcastReceiver {
    private static final String TAG = "AlarmReceiver";

    @Override
    public void onReceive(Context context, Intent intent) {
        if (intent == null) {
            return;
        }
        String action = intent.getAction();
        if (TextUtils.equals(action, IntentConst.Action.matchRemind)) {
            //通知比賽開始
            long matchID = intent.getLongExtra(Net.Param.ID, 0);
            showNotificationRemindMe(context, matchID);
        }

    }
}

AlarmUtil提供設定鬧鈴和取消鬧鈴的兩個方法

public class AlarmUtil {
    private static final String TAG = "AlarmUtil";

    public static void controlAlarm(Context context, long startTime,long matchId, Intent nextIntent) {
        AlarmManager alarmManager = (AlarmManager) context.getSystemService(Context.ALARM_SERVICE);
        PendingIntent pendingIntent = PendingIntent.getBroadcast(context, (int) matchId, nextIntent,
                PendingIntent.FLAG_ONE_SHOT);
        alarmManager.set(AlarmManager.RTC_WAKEUP, startTime, pendingIntent);
    }

    public static void cancelAlarm(Context context, String action,long matchId) {
        Intent intent = new Intent(action);
        PendingIntent sender = PendingIntent.getBroadcast(
                context, (int) matchId, intent, 0);

        // And cancel the alarm.
        AlarmManager alarmManager = (AlarmManager) context.getSystemService(Context.ALARM_SERVICE);
        alarmManager.cancel(sender);
    }


}

關注比賽的時候，會設定intent的action為IntentConst.Action.matchRemind，會根據比賽的開始時間提前半小時設定鬧鈴時間，取消關注比賽同時取消鬧鈴

   if (isSetAlarm) {
            long start_tm = matchInfo.getStart_tm();
            long warmTime = start_tm - 30 * 60;

            Intent intent = new Intent(IntentConst.Action.matchRemind);
            intent.putExtra(Net.Param.ID, matchInfo.getId());
            AlarmUtil.controlAlarm(context, warmTime * 1000,matchInfo.getId(), intent);

            Gson gson = new Gson();
            String json = gson.toJson(matchInfo);
            SportDao.getInstance(context).insertMatchFollow(eventID, matchInfo.getId(), json, matchInfo.getType());
        } else {
            AlarmUtil.cancelAlarm(context, IntentConst.Action.matchRemind,matchInfo.getId());
            SportDao.getInstance(context).deleteMatchFollowByID(matchInfo.getId());
        }

相關推薦

多種方式實現Android定時任務，哪一款是你的FEEL？

前言 專案中總是會因為各種需求新增各種定時任務，所以就打算小結一下Android中如何實現定時任務，下面的解決方案的案例大部分都已在實際專案中實踐，特此列出供需要的朋友參考，如果有什麼使用不當或者存在什麼問題，歡迎留言指出！直接上乾貨！ 解決方

Java：多種方式實現倒計時定時器

多種方式實現倒計時定時器 1、簡易方式實現 /** * @see * @author Al_assad [email protected] * @date 2016年10月18日 上

Android定時任務的實現方式

在日常的Android功能開發中，我們難免會碰到需要定時任務功能，例如定時輪詢某個介面，或者是每隔多長時間檢查一次本地資料，在本文中，主要介紹android中常用的兩種定時任務實現方式 使用Handler實現 使用RxJava實現 一、使用Handler實現定時任

Spring Boot 中配置定時任務，實現多線程操作

pre log pri http code china 部分 多線程操作 .net 參考的代碼部分 https://git.oschina.net/jokerForTao/spring_boot_schedule 一目了然！Spring Boot 中配置定時任務，實現

Spring+Quartz 從資料庫中獲取定時任務和定時時間，動態實現對定時任務的增刪改查

本文轉載自部落格：http://blog.csdn.net/wwkms/article/details/48851005 ----------------------------------------------------------------------------------------

spring定時任務實現動態定時任務（啟停，週期修改）

使用方法：             複製下方程式碼，在業務需要處呼叫（定時任務狀態和執行週期被修改後），一定要在專案啟動時後立刻執行一次庫中全資料呼叫此方法，List<Cron> crons   Cron中一定要有業務類的包加類名（com.rails.trave

android定時任務實現

android的系統定時器功能由AlarmManager類提供 AlarmManager提供了兩個介面供使用，分別是單次和迴圈定時功能，如下：AlarmManager提供了兩個介面供使用，分別是單次和迴圈定時功能，如下： public void set(int type,

SpringBoot整合Elastic-Job，實現動態建立定時任務，任務持久化

SpringBoot使用Elastic-Job-lite，實現動態建立定時任務，任務持久化 Elastic-Job是噹噹開源的一個分散式排程解決方案，由兩個相互獨立的子專案Elastic-Job-Lite和Elastic-Job-Cloud組成。 Elast

Python模組學習之Timer定時任務，函式自調實現定時獲取部落格園部落格瀏覽量

Timer定時任務 下面是Timer函式的官方doc介紹資訊 “”” Call a function after a specified number of seconds: t = Timer(30.0, f, args=No

[Android] Android 定時任務實現的三種方法(以SeekBar的進度自動實現為例)

orien nta callback 間隔 end ++ tar protect bundle [Android] Android 定時任務實現的三種方法(以SeekBar的進度自動實現為例) 一、采用Handler與線程的sleep(long)方法 二、采用H

spring + quartz定時任務，以及修改定時任務

blog public schedule col ping ppi string time 找到 spring4+quartz2.2.3，定時任務弄好了，修改定時任務沒折騰起，沒找到合適的解決方案。 最終使用庫spring-context-support 3.2.17.RE

springboot定時任務，去掉指定日期

bstr log tex ram static 依賴 測試 form 意思 　　今天用springboot寫到一個需求：每周定時發送任務，但是要避開法定節假日。 　　網上找了些博客看，主要參考了https://www.cnblogs.com/lic309/p/4089633

PHP實現執行定時任務的幾種思路詳解

編輯 exists sched ebs conn 多系統 環境 提高效率 pac HP本身是沒有定時功能的，PHP也不能多線程。PHP的定時任務功能必須通過和其他工具結合才能實現，例如WordPress內置了wp-

linux創建定時任務，定時執行sql

直接 nbsp back bash $path sys AS val pan 終於弄清楚一個問題了。linux創建定時任務，定時執行sql，其中分為兩個case。 case1 sql語句較少，因此直接在 shell腳本中 寫sql語句。如下： [oracle@Oracle1

管理大量定時任務，如果高效觸發超時？

img fff ima app 100% font nbsp back round 1. 背景 很多時候，業務有定時任務或定時超時的需求，當任務量很大時，可能需要維護大量的timer，或者進行低效的掃描。 例如：對每個用戶會維護一個APP到服務器的TCP連接，用來實時收

springboot和quartz整合實現動態定時任務（持久化單節點）

依賴 1.5 ostc read 自動 1.8 自動註入 etc string 　　Quartz是一個完全由java編寫的開源作業調度框架,為在Java應用程序中進行作業調度提供了簡單卻強大的機制，它支持定時任務持久化到數據庫，從而避免了重啟服務器時任務丟失，支持分布式多節

《SpringBoot從入門到放棄》之第（十一）篇——使用@Scheduled建立定時任務，cron七子表示式的簡單使用

模擬場景：有時候，你需要每天某個點或者每週、每個月讓程式做一些事情，如呼叫介面獲取資料，比如生成資料的報表，或者統計一些資料之類，你除了可以在資料庫建立儲存過程，還可以寫Java定時任務。 O的K，接著上一篇的開發環境。《SpringBoot從入門到放棄》之第（十）篇 我們建立一個定時任

springboot使用@Scheduled做定時任務，以及連線池問題

本人覺得@Scheduled使用起來太方便了，大大減少了程式碼量(2月份剛來公司的時候，還單純以為只用java的Timer來寫呢)，突然覺得springboot特別便利....。好了，不多說，開始寫@Scheduled部落格了。 這裡就說一些定時任務的簡單實用。首先需要在啟動類中加上@Ena

Storm框架：如何實現crontab定時任務

Storm除了能對訊息流進行處理，還能實現crontab定時任務。 只要在bolt中配置TOPOLOGY_TICK_TUPLE_FREQ_SECS項即可實現。 @Override public Map<String, Object> getComponentConfiguration() {

windows伺服器設定定時任務，各種語言都可以

一，先建立一個helloworld.bat檔案，並且搞懂這個檔案內容分別代表什麼意思 helloworld.bat檔案內容如下： D: cd D:\WWW\zjdx D:\phpstudy\php\php-5.5.38\php.exe D:\WWW\zjdx/index.php Home