2. 程式人生 > >定時AlarmManager迴圈執行後臺任務和多個定時迴圈後臺任務寫在一起

定時AlarmManager迴圈執行後臺任務和多個定時迴圈後臺任務寫在一起

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

定時迴圈執行某些任務，在開發中是很常見的一種方式，Android中有兩種定時器可以實現，一種是Alarm，另一種是AlarmManager，Alarm在Android4.4以後，這種方式的定時器不太準確，Android官方為了優化手機電池使用時間，將多個差不多時間差的Alarm定時器放在一起執行，導致部分計時器先執行或者或執行。相比於Alarm，AlarmManager是準確執行的。所以這裡我們不考慮Alarm定時器，以AlarmManager作為示例。

1. 建立一個定時迴圈任務（定時迴圈後臺任務建立挺簡單的，主要是多個定時迴圈會有些麻煩），按照慣例，先直接上程式碼。

  • 首先建立一個介面TimeTask.java，直觀地顯示出後臺的執行資訊。
import android.content.Intent;
import android.content.SharedPreferences;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;

import com.example.mrc.csdndemo.R;

public class TimeTask extends AppCompatActivity implements
 
 View.OnClickListener {

    Button mOpenBtn ,mCloseBtn ,mOpenMoreBtn ,mCloseMoreBtn;
    Intent mOneIntent = null ;
    Intent mMoreIntent =null;
    TimeTaskService timeTaskService ;
    SharedPreferences sharedPreferences ;
    SharedPreferences.Editor editor ;

    @Override
    protected void onCreate
 
(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_time_task);
        /*sharedPreferences =getApplicationContext().getSharedPreferences("com.example.mrc.csdnDemo" , 0);
        editor=sharedPreferences.edit();
        editor.putInt("count",0);
        editor.commit();*/

        findView();
        Init();
    }

    void findView(){
        mOpenBtn = (Button)findViewById(R.id.open_time_task);
        mCloseBtn = (Button)findViewById(R.id.close_time_task);
        mOpenMoreBtn = (Button)findViewById(R.id.open_more_time_task);
        mCloseMoreBtn = (Button)findViewById(R.id.close_more_time_task);

        mOpenBtn.setOnClickListener(this);
        mCloseBtn.setOnClickListener(this);
        mOpenMoreBtn.setOnClickListener(this);
        mCloseMoreBtn.setOnClickListener(this);
    }

    void Init(){

    }

    @Override
    public void onClick(View v) {
        switch(v.getId()){
            case R.id.open_time_task :
                mOneIntent =new Intent(this ,TimeTaskService.class) ;
                /*mOneIntent.setAction("ITOP.MOBILE.SIMPLE.SERVICE.SENSORSERVICE");*/
                startService(mOneIntent);
                break;
            case R.id.close_time_task :
                Intent intentOneStop = new Intent(this, TimeTaskService.class);
                /*Intent intent =new Intent();*/
               /* intent.setAction("ITOP.MOBILE.SIMPLE.SERVICE.SENSORSERVICE");*/  //android5.0以下才適合使用
                stopService(intentOneStop);
                break;
            case R.id.open_more_time_task :
                mMoreIntent =new Intent(this ,MoreTimeTaskService.class) ;
                /*mOneIntent.setAction("ITOP.MOBILE.SIMPLE.SERVICE.SENSORSERVICE");*/
                startService(mMoreIntent);
                break;
            case R.id.close_more_time_task :
                Intent intentMoreStop = new Intent(this, MoreTimeTaskService.class);
                /*Intent intentMoreStop =new Intent();*/
               /* intent.setAction("ITOP.MOBILE.SIMPLE.SERVICE.SENSORSERVICE");*/  //android5.0以下才適合使用
                stopService(intentMoreStop);
                break;
            default:break;
        }
    }
}
  • 相對應的activity_time_task.xml佈局
<ScrollView xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context="com.example.mrc.csdndemo.BackgroundTimeTask.TimeTask">
    <LinearLayout
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:orientation="vertical"
        android:layout_gravity="center">
        <Button
            android:id="@+id/open_time_task"
            android:layout_gravity="center_horizontal"
            android:layout_width="240dp"
            android:layout_height="48dp"
            android:text="開啟一個定時任務"
            android:background="@drawable/button_style"
            android:textSize="17sp"
            android:textColor="@color/text_white"
            android:layout_marginTop="16dp"/>
        <Button
            android:id="@+id/close_time_task"
            android:layout_gravity="center_horizontal"
            android:layout_width="240dp"
            android:layout_height="48dp"
            android:text="關閉一個定時任務"
            android:background="@drawable/button_style"
            android:textSize="17sp"
            android:textColor="@color/text_white"
            android:layout_marginTop="16dp"/>
        <Button
            android:id="@+id/open_more_time_task"
            android:layout_gravity="center_horizontal"
            android:layout_width="240dp"
            android:layout_height="48dp"
            android:text="開啟多個定時任務"
            android:background="@drawable/button_style"
            android:textSize="17sp"
            android:textColor="@color/text_white"
            android:layout_marginTop="16dp"/>
        <Button
            android:id="@+id/close_more_time_task"
            android:layout_gravity="center_horizontal"
            android:layout_width="240dp"
            android:layout_height="48dp"
            android:text="關閉多個定時任務"
            android:background="@drawable/button_style"
            android:textSize="17sp"
            android:textColor="@color/text_white"
            android:layout_marginTop="16dp"/>
    </LinearLayout>
</ScrollView>

介面效果如下：
這裡寫圖片描述

  • 以上都不用解釋，相信都能看懂，接下來建立後臺服務的事情
    建立一個後臺服務：TimeTaskService.java ，這個服務在沒有特殊情況下是不會關閉的
import android.app.AlarmManager;
import android.app.PendingIntent;
import android.app.Service;
import android.content.Intent;
import android.content.SharedPreferences;
import android.os.Build;
import android.os.Handler;
import android.os.IBinder;
import android.os.Looper;
import android.os.SystemClock;
import android.util.Log;
import android.widget.Toast;

import java.lang.reflect.Field;
import java.util.Calendar;

public class TimeTaskService extends Service {

    private static final int INTERVAL_TIME  = 10 ;
    AlarmManager alarmManager ;
    PendingIntent pIntent ;
    SharedPreferences sharedPreferences ;
    SharedPreferences.Editor editor ;
    Calendar mCalendar ;
    public TimeTaskService() {
    }

    @Override
    public IBinder onBind(Intent intent) {
        // TODO: Return the communication channel to the service.
        throw new UnsupportedOperationException("Not yet implemented");
    }

    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        sharedPreferences =getApplicationContext().getSharedPreferences("com.example.mrc.csdnDemo" , 0);
        sharedPreferences.edit();
        //這裡模擬後臺操作
        Handler handler=new Handler(Looper.getMainLooper());
        handler.post(new Runnable(){
            public void run(){
                int count =sharedPreferences.getInt("count" ,0);
                count ++ ;
                Log.e("messages","迴圈執行了"+ count +"次定時任務，執行時間為："+ System.currentTimeMillis());
                Toast.makeText(getApplicationContext() ,"迴圈執行了"+ count +"次定時任務，執行時間為："+ System.currentTimeMillis() ,Toast.LENGTH_LONG).show();
                editor = sharedPreferences.edit();
                editor.putInt("count" ,count);
                editor.commit();
            }
        });

        mCalendar = Calendar.getInstance();
        mCalendar.setTimeInMillis(System.currentTimeMillis());
        mCalendar.add(Calendar.SECOND, INTERVAL_TIME);
        //通過AlarmManager定時啟動廣播
        alarmManager= (AlarmManager) getSystemService(ALARM_SERVICE);
        Intent timeTaskIntent=new Intent(this, AlarmReceiver.class);
        pIntent=PendingIntent.getBroadcast(this,0,timeTaskIntent ,PendingIntent.FLAG_CANCEL_CURRENT);
        int apiLevel = getApiLevel();
        if (apiLevel < Build.VERSION_CODES.KITKAT) {
            Log.d("api<19", "setExactAlarmCompat ");
            alarmManager.setRepeating(AlarmManager.RTC_WAKEUP, mCalendar.getTimeInMillis(), INTERVAL_TIME, pIntent);
        } else if (Build.VERSION.SDK_INT < Build.VERSION_CODES.M) {
            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
                alarmManager.setExact(AlarmManager.RTC_WAKEUP, mCalendar.getTimeInMillis(), pIntent);
            }
            Log.d("19<api<23", "setExactAlarmCompat ");
        } else if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
            alarmManager.setExactAndAllowWhileIdle(AlarmManager.RTC_WAKEUP, mCalendar.getTimeInMillis(), pIntent);
            Log.d("api>23", "setExactAlarmCompat ");
        }
        return super.onStartCommand(intent, flags, startId);
    }

    public static int getApiLevel() {
        try {
            Field f = Build.VERSION.class.getField("SDK_INT");
            f.setAccessible(true);
            return f.getInt(null);
        } catch (Throwable e) {
            return 3;
        }
    }
    @Override
    public void onDestroy(){
        alarmManager.cancel(pIntent);
        Handler handler=new Handler(Looper.getMainLooper());
        handler.post(new Runnable(){
            public void run() {
                Toast.makeText(getApplicationContext() ,"停止後臺迴圈任務，停止執行時間為："
                                + System.currentTimeMillis() , Toast.LENGTH_LONG ).show();
            }
        });
        Log.e("messages","停止後臺迴圈任務，停止執行時間為："+ System.currentTimeMillis());
    }
}

這是建立一個定時後臺服務的主要程式碼：

mCalendar = Calendar.getInstance();
        mCalendar.setTimeInMillis(System.currentTimeMillis());
        mCalendar.add(Calendar.SECOND, INTERVAL_TIME);
        //通過AlarmManager定時啟動廣播
        alarmManager= (AlarmManager) getSystemService(ALARM_SERVICE);
        Intent timeTaskIntent=new Intent(this, AlarmReceiver.class);
        pIntent=PendingIntent.getBroadcast(this,0,timeTaskIntent ,PendingIntent.FLAG_CANCEL_CURRENT);
        int apiLevel = getApiLevel();
        if (apiLevel < Build.VERSION_CODES.KITKAT) {
            Log.d("api<19", "setExactAlarmCompat ");
            alarmManager.setRepeating(AlarmManager.RTC_WAKEUP, mCalendar.getTimeInMillis(), INTERVAL_TIME, pIntent);
        } else if (Build.VERSION.SDK_INT < Build.VERSION_CODES.M) {
            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
                alarmManager.setExact(AlarmManager.RTC_WAKEUP, mCalendar.getTimeInMillis(), pIntent);
            }
            Log.d("19<api<23", "setExactAlarmCompat ");
        } else if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
            alarmManager.setExactAndAllowWhileIdle(AlarmManager.RTC_WAKEUP, mCalendar.getTimeInMillis(), pIntent);
            Log.d("api>23", "setExactAlarmCompat ");
        }

AlarmManager是一個定時器，在不同的Android版本里AlarmManager的執行方法也不同，具體看程式碼。 PendingIntent是一個即將執行的意圖，和Intent的最主要的區別是PendingIntent是即將執行的，Intent是立即執行的，怎麼解釋呢，就是PendingIntent是等待某些訊號才執行一般配合AlarmManager或者Alarm等一起使用。PendingIntent的使用方法和Intent也有很大差異。在PendingIntent裡還嵌入一個Intent，這才是真正的意圖。

  • 執行TimeTaskService服務後，會跳轉到一個廣播類，廣播類會定時回撥TimeTaskService服務，這樣就做到定時迴圈執行的效果。其實挺簡單的。下面是AlarmReceiver.java廣播類的程式碼：
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.SharedPreferences;

public class AlarmReceiver extends BroadcastReceiver {
    SharedPreferences sharedPreferences ;
    SharedPreferences.Editor editor ;
    @Override
    public void onReceive(Context context, Intent intent) {
        Intent i = new Intent(context, TimeTaskService.class);
        context.startService(i);
    }

}

仔細看程式碼，感覺也不是很難，這種定時後臺任務其實很常用，學一學沒什麼弊端。

2.定時迴圈執行多個任務（這裡指的是在一個後臺服務裡執行定時間隔都不一樣的任務，這要解決如何知道執行了哪一個定時任務，又不影響其他定時任務的問題，當然，建立多個服務和廣播類也可以實現，但是博主比較死心眼，就想在一個服務Service裡把所有需求實現。後來通過不斷摸索，最終實現了），按照慣例，先獻上程式碼：

  • 介面的實現和上面一致，這裡就不多說了，直接說後臺服務。建立MoreTimeTaskService.java服務，程式碼如下：
import android.app.AlarmManager;
import android.app.AlertDialog;
import android.app.PendingIntent;
import android.app.Service;
import android.content.DialogInterface;
import android.content.Intent;
import android.content.SharedPreferences;
import android.os.Build;
import android.os.Handler;
import android.os.IBinder;
import android.os.Looper;
import android.util.Log;
import android.view.WindowManager;
import android.widget.Toast;

import java.lang.reflect.Field;
import java.util.Calendar;

public class MoreTimeTaskService extends Service {
    private static final int INTERVAL_TIME_ONE  = 10 ;
    private static final int INTERVAL_TIME_TWO  = 15 ;
    private static final int INTERVAL_TIME_THREE  = 20 ;
    AlarmManager mAlarmManagerOne;
    AlarmManager mAlarmManagerTwo;
    AlarmManager mAlarmManagerThree;
    PendingIntent pIntentOne ;
    PendingIntent pIntentTwo ;
    PendingIntent pIntentThree ;
    SharedPreferences sharedPreferences ;
    SharedPreferences.Editor editor ;
    Calendar mCalendar ;

    public MoreTimeTaskService() {
    }

    @Override
    public IBinder onBind(Intent intent) {
        // TODO: Return the communication channel to the service.
        throw new UnsupportedOperationException("Not yet implemented");
    }

    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        sharedPreferences =getApplicationContext().getSharedPreferences("com.example.mrc.csdnDemo" , 0);
        sharedPreferences.edit();
        int type = sharedPreferences.getInt("type" ,0);
        //1表示執行第一個定時任務 2，3同理 ；0表示未執行，則三個一起執行
        mCalendar = Calendar.getInstance();
        mCalendar.setTimeInMillis(System.currentTimeMillis());
        int apiLevel = getApiLevel();

        //這裡模擬後臺操作
        if(type ==0){
            Handler handlerOne=new Handler(Looper.getMainLooper());
            handlerOne.post(new Runnable(){
                public void run(){
                    int countOne =sharedPreferences.getInt("countOne" ,0);
                    countOne ++ ;
                    Log.e("messages","第1個定時任務迴圈執行了"+ countOne +"次，執行時間為："+ System.currentTimeMillis());
                    Toast.makeText(getApplicationContext() ,"第1個定時任務迴圈執行了"+ countOne +"次，執行時間為："+ System.currentTimeMillis() ,Toast.LENGTH_LONG).show();
                    editor = sharedPreferences.edit();
                    editor.putInt("countOne" ,countOne);
                    editor.commit();
                }
            });
            Handler handlerTwo=new Handler(Looper.getMainLooper());
            handlerTwo.post(new Runnable(){
                public void run(){
                    int countTwo =sharedPreferences.getInt("countTwo" ,0);
                    countTwo ++ ;
                    Log.e("messages","第2個定時任務迴圈執行了"+ countTwo +"次，執行時間為："+ System.currentTimeMillis());
                    Toast.makeText(getApplicationContext() ,"第2個定時任務迴圈執行了"+ countTwo +"次，執行時間為："+ System.currentTimeMillis() ,Toast.LENGTH_LONG).show();
                    editor = sharedPreferences.edit();
                    editor.putInt("countTwo" ,countTwo);
                    editor.commit();
                }
            });
            Handler handlerThree=new Handler(Looper.getMainLooper());
            handlerThree.post(new Runnable(){
                public void run(){
                    int countThree =sharedPreferences.getInt("countThree" ,0);
                    countThree ++ ;
                    Log.e("messages","第3個定時任務迴圈執行了"+ countThree +"次，執行時間為："+ System.currentTimeMillis());
                    Toast.makeText(getApplicationContext() ,"第3個定時任務迴圈執行了"+ countThree +"次，執行時間為："+ System.currentTimeMillis() ,Toast.LENGTH_LONG).show();
                    editor = sharedPreferences.edit();
                    editor.putInt("countThree" ,countThree);
                    editor.commit();
                }
            });

            mCalendar.add(Calendar.SECOND, INTERVAL_TIME_ONE);
            //通過AlarmManager定時啟動廣播
            mAlarmManagerOne= (AlarmManager) getSystemService(ALARM_SERVICE);
            Intent timeTaskIntentOne=new Intent(this, MoreAlarmReceiver.class);
            timeTaskIntentOne.putExtra("type" ,1);
            pIntentOne=PendingIntent.getBroadcast(this,1,timeTaskIntentOne ,PendingIntent.FLAG_CANCEL_CURRENT);
            if (apiLevel < Build.VERSION_CODES.KITKAT) {
                Log.d("api<19", "setExactAlarmCompat ");
                mAlarmManagerOne.setRepeating(AlarmManager.RTC_WAKEUP, mCalendar.getTimeInMillis(), INTERVAL_TIME_ONE, pIntentOne);
            } else if (Build.VERSION.SDK_INT < Build.VERSION_CODES.M) {
                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
                    mAlarmManagerOne.setExact(AlarmManager.RTC_WAKEUP, mCalendar.getTimeInMillis(), pIntentOne);
                }
                Log.d("19<api<23", "setExactAlarmCompat ");
            } else if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
                mAlarmManagerOne.setExactAndAllowWhileIdle(AlarmManager.RTC_WAKEUP, mCalendar.getTimeInMillis(), pIntentOne);
                Log.d("api>23", "setExactAlarmCompat ");
            }

            mCalendar.add(Calendar.SECOND, INTERVAL_TIME_TWO);
            //通過AlarmManager定時啟動廣播
            mAlarmManagerTwo= (AlarmManager) getSystemService(ALARM_SERVICE);
            Intent timeTaskIntentTwo=new Intent(this, MoreAlarmReceiver.class);
            timeTaskIntentTwo.putExtra("type" ,2) ;
            pIntentTwo=PendingIntent.getBroadcast(this,2,timeTaskIntentTwo ,PendingIntent.FLAG_CANCEL_CURRENT);
            if (apiLevel < Build.VERSION_CODES.KITKAT) {
                Log.d("api<19", "setExactAlarmCompat ");
                mAlarmManagerTwo.setRepeating(AlarmManager.RTC_WAKEUP, mCalendar.getTimeInMillis(), INTERVAL_TIME_TWO, pIntentTwo);
            } else if (Build.VERSION.SDK_INT < Build.VERSION_CODES.M) {
                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
                    mAlarmManagerTwo.setExact(AlarmManager.RTC_WAKEUP, mCalendar.getTimeInMillis(), pIntentTwo);
                }
                Log.d("19<api<23", "setExactAlarmCompat ");
            } else if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
                mAlarmManagerTwo.setExactAndAllowWhileIdle(AlarmManager.RTC_WAKEUP, mCalendar.getTimeInMillis(), pIntentTwo);
                Log.d("api>23", "setExactAlarmCompat ");
            }

            mCalendar.add(Calendar.SECOND, INTERVAL_TIME_THREE);
            //通過AlarmManager定時啟動廣播
            mAlarmManagerThree= (AlarmManager) getSystemService(ALARM_SERVICE);
            Intent timeTaskIntentThree=new Intent(this, MoreAlarmReceiver.class);
            timeTaskIntentThree.putExtra("type" ,3) ;
            pIntentThree=PendingIntent.getBroadcast(this,3,timeTaskIntentThree ,PendingIntent.FLAG_CANCEL_CURRENT);
            if (apiLevel < Build.VERSION_CODES.KITKAT) {
                Log.d("api<19", "setExactAlarmCompat ");
                mAlarmManagerThree.setRepeating(AlarmManager.RTC_WAKEUP, mCalendar.getTimeInMillis(), INTERVAL_TIME_THREE, pIntentThree);
            } else if (Build.VERSION.SDK_INT < Build.VERSION_CODES.M) {
                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
                    mAlarmManagerThree.setExact(AlarmManager.RTC_WAKEUP, mCalendar.getTimeInMillis(), pIntentThree);
                }
                Log.d("19<api<23", "setExactAlarmCompat ");
            } else if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
                mAlarmManagerThree.setExactAndAllowWhileIdle(AlarmManager.RTC_WAKEUP, mCalendar.getTimeInMillis(), pIntentThree);
                Log.d("api>23", "setExactAlarmCompat ");
            }

        } else if(type ==1){
            Handler handlerOne=new Handler(Looper.getMainLooper());
            handlerOne.post(new Runnable(){
                public void run(){
                    int countOne =sharedPreferences.getInt("countOne" ,0);
                    countOne ++ ;
                    Log.e("messages","第1個定時任務迴圈執行了"+ countOne +"次，執行時間為："+ System.currentTimeMillis());
                    Toast.makeText(getApplicationContext() ,"第1個定時任務迴圈執行了"+ countOne +"次，執行時間為："+ System.currentTimeMillis() ,Toast.LENGTH_LONG).show();
                    editor = sharedPreferences.edit();
                    editor.putInt("countOne" ,countOne);
                    editor.commit();
                }
            });

            mCalendar.add(Calendar.SECOND, INTERVAL_TIME_ONE);
            //通過AlarmManager定時啟動廣播
            mAlarmManagerOne= (AlarmManager) getSystemService(ALARM_SERVICE);
            Intent timeTaskIntentOne=new Intent(this, MoreAlarmReceiver.class);
            timeTaskIntentOne.putExtra("type" ,1);
            pIntentOne=PendingIntent.getBroadcast(this,1,timeTaskIntentOne ,PendingIntent.FLAG_CANCEL_CURRENT);
            if (apiLevel < Build.VERSION_CODES.KITKAT) {
                Log.d("api<19", "setExactAlarmCompat ");
                mAlarmManagerOne.setRepeating(AlarmManager.RTC_WAKEUP, mCalendar.getTimeInMillis(), INTERVAL_TIME_ONE, pIntentOne);
            } else if (Build.VERSION.SDK_INT < Build.VERSION_CODES.M) {
                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
                    mAlarmManagerOne.setExact(AlarmManager.RTC_WAKEUP, mCalendar.getTimeInMillis(), pIntentOne);
                }
                Log.d("19<api<23", "setExactAlarmCompat ");
            } else if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
                mAlarmManagerOne.setExactAndAllowWhileIdle(AlarmManager.RTC_WAKEUP, mCalendar.getTimeInMillis(), pIntentOne);
                Log.d("api>23", "setExactAlarmCompat ");
            }
        }else if(type ==2){
            Handler handlerTwo=new Handler(Looper.getMainLooper());
            handlerTwo.post(new Runnable(){
                public void run(){
                    int countTwo =sharedPreferences.getInt("countTwo" ,0);
                    countTwo ++ ;
                    Log.e("messages","第2個定時任務迴圈執行了"+ countTwo +"次，執行時間為："+ System.currentTimeMillis());
                    Toast.makeText(getApplicationContext() ,"第2個定時任務迴圈執行了"+ countTwo +"次，執行時間為："+ System.currentTimeMillis() ,Toast.LENGTH_LONG).show();
                    editor = sharedPreferences.edit();
                    editor.putInt("countTwo" ,countTwo);
                    editor.commit();
                }
            });

            mCalendar.add(Calendar.SECOND, INTERVAL_TIME_TWO);
            //通過AlarmManager定時啟動廣播
            mAlarmManagerTwo= (AlarmManager) getSystemService(ALARM_SERVICE);
            Intent timeTaskIntentTwo=new Intent(this, MoreAlarmReceiver.class);
            timeTaskIntentTwo.putExtra("type" ,2);
            pIntentTwo=PendingIntent.getBroadcast(this,2,timeTaskIntentTwo ,PendingIntent.FLAG_CANCEL_CURRENT);
            if (apiLevel < Build.VERSION_CODES.KITKAT) {
                Log.d("api<19", "setExactAlarmCompat ");
                mAlarmManagerTwo.setRepeating(AlarmManager.RTC_WAKEUP, mCalendar.getTimeInMillis(), INTERVAL_TIME_TWO, pIntentTwo);
            } else if (Build.VERSION.SDK_INT < Build.VERSION_CODES.M) {
                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
                    mAlarmManagerTwo.setExact(AlarmManager.RTC_WAKEUP, mCalendar.getTimeInMillis(), pIntentTwo);
                }
                Log.d("19<api<23", "setExactAlarmCompat ");
            } else if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
                mAlarmManagerTwo.setExactAndAllowWhileIdle(AlarmManager.RTC_WAKEUP, mCalendar.getTimeInMillis(), pIntentTwo);
                Log.d("api>23", "setExactAlarmCompat ");
            }

        }else if(type ==3){
            Handler handlerThree=new Handler(Looper.getMainLooper());
            handlerThree.post(new Runnable(){
                public void run(){
                    int countThree =sharedPreferences.getInt("countThree" ,0);
                    countThree ++ ;
                    Log.e("messages","第3個定時任務迴圈執行了"+ countThree +"次，執行時間為："+ System.currentTimeMillis());
                    Toast.makeText(getApplicationContext() ,"第3個定時任務迴圈執行了"+ countThree +"次，執行時間為："+ System.currentTimeMillis() ,Toast.LENGTH_LONG).show();
                    editor = sharedPreferences.edit();
                    editor.putInt("countThree" ,countThree);
                    editor.commit();
                }
            });

            mCalendar.add(Calendar.SECOND, INTERVAL_TIME_THREE);
            //通過AlarmManager定時啟動廣播
            mAlarmManagerThree= (AlarmManager) getSystemService(ALARM_SERVICE);
            Intent timeTaskIntentThree=new Intent(this, MoreAlarmReceiver.class);
            timeTaskIntentThree.putExtra("type" ,3);
            pIntentThree=PendingIntent.getBroadcast(this,3,timeTaskIntentThree ,PendingIntent.FLAG_CANCEL_CURRENT);
            if (apiLevel < Build.VERSION_CODES.KITKAT) {
                Log.d("api<19", "setExactAlarmCompat ");
                mAlarmManagerThree.setRepeating(AlarmManager.RTC_WAKEUP, mCalendar.getTimeInMillis(), INTERVAL_TIME_THREE, pIntentThree);
            } else if (Build.VERSION.SDK_INT < Build.VERSION_CODES.M) {
                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
                    mAlarmManagerThree.setExact(AlarmManager.RTC_WAKEUP, mCalendar.getTimeInMillis(), pIntentThree);
                }
                Log.d("19<api<23", "setExactAlarmCompat ");
            } else if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
                mAlarmManagerThree.setExactAndAllowWhileIdle(AlarmManager.RTC_WAKEUP, mCalendar.getTimeInMillis(), pIntentThree);
                Log.d("api>23", "setExactAlarmCompat ");
            }

        }
        return super.onStartCommand(intent, flags, startId);
    }

    public static int getApiLevel() {
        try {
            Field f = Build.VERSION.class.getField("SDK_INT");
            f.setAccessible(true);
            return f.getInt(null);
        } catch (Throwable e) {
            return 3;
        }
    }
    @Override
    public void onDestroy(){

        Handler handler=new Handler(Looper.getMainLooper());
        handler.post(new Runnable(){
            public void run() {
                mAlarmManagerOne.cancel(pIntentOne);
                Toast.makeText(getApplicationContext() ,"停止了第1個後臺迴圈任務，停止執行時間為："
                        + System.currentTimeMillis() , Toast.LENGTH_LONG ).show();

                mAlarmManagerTwo.cancel(pIntentTwo);
                Toast.makeText(getApplicationContext() ,"停止了第2個後臺迴圈任務，停止執行時間為："
                        + System.currentTimeMillis() , Toast.LENGTH_LONG ).show();

                mAlarmManagerThree.cancel(pIntentThree);
                Toast.makeText(getApplicationContext() ,"停止了第3個後臺迴圈任務，停止執行時間為："
                        + System.currentTimeMillis() , Toast.LENGTH_LONG ).show();

相關推薦

定時AlarmManager迴圈執行後臺任務和多個定時迴圈後臺任務寫在一起

定時迴圈執行某些任務，在開發中是很常見的一種方式，Android中有兩種定時器可以實現，一種是Alarm，另一種是AlarmManager，Alarm在Android4.4以後，這種方式的定時器不太準確，Android官方為了優化手機電池使用時間，將多個差不多時

tensorflow的session.run執行一個op和多個op的區別

背景： session.run方法可以傳入一個op，也可以傳入op列表，例如，我們希望執行op1和op2，有兩種寫法： sess.run(op1) sess.run(op2) 和 sess.run([op1, op2]) 如果op1和op2有相互包含關係，第寫法1會將op1和

AlarmManager實現建立多個定時任務功能

需求情景：  接收伺服器下發的定時任務：定時亮屏、定時調節音量、定時調節亮度。 具體定時任務： 音量和亮度只需要在開始時間去執行，電源開關（其實是系統開關屏）需要在開始時間開啟，結束時間關閉。 具體調節亮度、音量、開關屏操作暫不講述。 1.獲取需要執行的

springboot動態配置定時任務2種方式，整合Quartz多執行緒併發執行多個定時任務配置

我的專案是採用的idea+gradle+springboot專案構建，下面是springboot實現定時任務所需要的jar包 //定時任務使用 compile group: 'org.quartz-scheduler', name: 'quartz', version:

C# 基礎知識系列- 12 任務和多執行緒

0. 前言 照例一份前言，在介紹任務和多執行緒之前，先介紹一下非同步和同步的概念。我們之間介紹的知識點都是在同步執行，所謂的同步就是一行程式碼一行程式碼的執行，就像是我們日常乘坐地鐵通過安檢通道一樣，想象我們每個人都是一行程式碼，我們依次通過安檢儀器的時候就是同步。 那麼，什麼是非同步呢？有一個時間利用率的故

Python開發【筆記】：單線程下執行多個定時器

自動 代碼 python 線程 timer ont -s 大量 過多 單線程多定時器 　　前言：公司業務需求，實例當中大量需要啟動定時器的操作；大家都知道python中的定時器用的是threading.Timer，每當啟動一個定時器時，程序內部起了一個線程，定時器觸發執行結

spring多個定時任務quartz配置

ram 至少 utf-8 list 表達 lse 第一個 span cron spring多個定時任務quartz配置 1 <?xml version=”1.0″ encoding=”UTF-8″?> 2 <beans xmlns=”http:/

在當java有多個jar包和多個檔案時，如何在控制檯編譯執行

編譯 javac -cp .:/root/java/hash2/lib/mysql-connector-java-5.1.35-bin.jar:/root/java/hash2/lib/c3p0-0.9.1.1.jar *.java   執行 java -cp .:

Android AlarmManager設定多個定時事件時只最後一個有效問題解決

最近用到了AlarmManager，遇到了問題，當我設定多個定時器時，發現只有一個起作用，百思不得其解，後來在網上找到了原因，把人家的解決辦法貼上： AlarmManager的常用方法有三個： (1)set(int type，long startTime，Pending

Spring Task 定時器如何在專案啟動時一次性註冊多個定時器任務

使用情景：前面的一篇文章已經說明了如何通過外部訪問，在不停伺服器的情況下動態的修改cron引數值，從而達到動態的修改定時器的任務，有需要的可以參考文章： 動態修改引數cron的值來實現Spring自帶定時器動態的執行任務，但是還有一種情況就是能不能不是通過外部修改，而是直接

大量資料情況下單執行緒插入和多執行緒insert資料庫的效能測試

之前一直沒有遇到過大批量資料入庫的場景，所以一直沒有思考過在大量資料的情況下單執行緒插入和多執行緒插入的效能情況。今天在看一個專案原始碼的時候發現使用了多執行緒insert操作。 於是簡單的寫了一個測試程式來測試一批資料在N個執行緒下的insert情況。 public class ThreadImport

使用 hashMap和treeMap開啟多個攝像頭的監控任務

背景：今天有個需求，傳人多個攝像頭ID，然後呼叫介面，開啟這些攝像頭的監控任務。   方法一： 如果你的攝像頭監控任務格式為： {camera_id_list=[{createBy=tjt, cameraId=camera01, startTime=2019-1-10 22:58:19},

springboot 整合quartz 建立多個定時任務

1.pom.xml <dependency> <groupId>org.quartz-scheduler</groupId> <artifactId>quartz</artifactId>

SpringBoot+Quartz實現多個定時任務

通過Timer和Spring的scheduler實現定時任務可能會出現一旦定時任務中斷後續的定時任務無法正常執行的問題，Quartz能夠很好的解決這一問題。 專案使用Maven管理，因此在使用之前需要在pom檔案中新增依賴，如下：     <dependency&g

詳解多執行緒MT和多執行緒MD的區別

區別1：全域性堆控制代碼不一樣。 網上有一個說法，就是一個執行緒一個棧，一個模組一個堆。前者很容易有理解，每個執行緒建立的時候在CreateThread中都能制定預設棧大小，只是很多情況下都取了預設值。而一個模組一個堆呢？其實很簡單測試，如果是一個多執行緒MT編譯方式的程

使用spring+quartz配置多個定時任務

Spring被用在了越來越多的專案中, quartz也被公認為是比較好用的定時器設定工具, 在這裡通過一個demo說明如何使用spring和quartz配置多個定時任務. 環境: eclipse + maven + spring 3.0.6.RELEASE版本 + quar

【Swoole基礎】Linux的多執行緒切換和多程序的切換

將大象裝冰箱，總共分三步，一把冰箱門開啟，二把大象轉進去，三把冰箱門關上，簡單粗暴。可惜我們的程序和執行緒的轉換不是大象裝冰箱問題，不扯淡了，迴歸正題。 一般的程序切換分為兩步 首先 切換頁目錄使用新的地址空間 然後 切換核心棧和硬體上下文 對於我們

關於JavaScript閉包中for迴圈執行順序(this和trs[i]問題)

.over{ Background:red; } .out{ Background:white; } var trs=document.getElementsByTagName("tr"); for(var i=0;i<trs.length;i+

多個定時器任務

min interval val http type inter doctype .com time <!DOCTYPE html> <html lang="zh-CN"> <head> <meta charset

真是奇怪，js可以，jq卻開啟了多個定時器，誰能解答一下

eve body stop 時鐘 time 就會 set () 方式 timer = setInterval(mar,30); //鼠標移上去清除時鐘 box.onmouseover = function(event){