阅读郭林《第一行代码》的笔记——第9章 后台默默的劳动者，探究服务

一、服务是什么，Android多线程编程

1、服务是什么

服务（Service）是Android中实现程序后台运行的解决方案，它非常适合用于去执行那些不需要和用户交互而且还要求长期运行的任务。服务的运行不依赖于任何用户界面，即使当程序被切换到后台，或者用户打开了另外一个应用程序，服务仍然能够保持正常运行。不过需要注意的是，服务并不是运行在一个独立的进程当中的，而是依赖于创建服务时所在的应用程序进程。当某个应用程序进程被杀掉时，所有依赖于该进程的服务也会停止运行。另外，也不要被服务的后台概念所迷惑，实际上服务并不会自动开启线程，所有的代码都是默认运行在主线程当中的。也就是说，我们需要在服务的内部手动创建子线程，并在这里执行具体的任务，否则就有可能出现主线程被阻塞住的情况。

2、Android多线程编程

当我们需要执行一些耗时操作，比如说发起一条网络请求时，考虑到网速等其他原因，服务器未必会立刻响应我们的请求，如果不将这类操作放在子线程里去运行，就会导致主线程被阻塞住，从而影响用户对软件的正常使用。

（1）线程的基本用法

Android多线程编程其实并不比Java多线程编程特珠，基本都是使用相同的语法。比如说，定义一个线程只需要新建一个类继承自Thread，然后重写父类的run()方法，并在里面编写耗时逻辑即可，如下所示：

class MyThread extends Thread {
    @Override
    public void run() {
        // 处理具体的逻辑
    } 
}

那么该如何启动这个线程呢？其实也很简单，只需要new出MyThread的实例，然后调用它的start()方法，这样run()方法中的代码就会在子线程当中运行了，如下所示：

new MyThread().start();

当然，使用继承的方式耦合性有点高，更多的时候我们都会选择使用实现Runnable接口的方式来定义一个线程，如下所示：

class MyThread implements Runnable {
    @Override
    public void run() {
        // 处理具体的逻辑
    }
}

如果使用了这种写法，启动线程的方法也需要进行相应的改变，如下所示：

MyThread myThread = new MyThread();
new Thread(myThread).start();

可以看到，Thread的构造函数接收一个Runnable参数，而我们new出的MyThread正是一个实现了Runnable接口的对象，所以可以直接将它传入到Thread的构造函数里。接着调用Thread的start()方法，run()方法中的代码就会在子线程当中运行了。
当然，如果你不想专门再定义一个类去实现Runnable接口，也可以使用匿名类的方式，这种写法更为常见，如下所示：

new Thread(new Runnable() {

    @Override
    public void run() {
        // 处理具体的逻辑
    }
}).start();

（2）在子线程中更新UI——Error
和许多其他的GUI库一样，Android的UI也是线程不安全的。也就是说，如果想要更新应用程序里的UI元素，则必须在主线程中进行，否则就会出现异常。对于这种情况，Android提供了一套异步消息处理机制，完美地解决了在子线程中进行UI操作的问题。
下面是一个简单的例子来说明要在主线程更新UI。
布局文件：

<?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">

    <Button
        android:id="@+id/btn_change"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="Change Text" />

    <TextView
        android:id="@+id/txt_content"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_centerInParent="true"
        android:text="Hello World" />
</RelativeLayout>

Java文件：

package com.test.thread;

import android.os.Handler;
import android.os.Message;
import android.support.v7.app.ActionBarActivity;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;
import android.widget.TextView;

import com.test.R;

public class ThreadActivity extends ActionBarActivity {
    private Button btnChange;
    private TextView txtContent;

    private static final int UPDATE_TEXT = 1;//定义了一个整型常量UPDATE_TEXT，用于表示更新TextView这个动作。

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_thread);
        btnChange = (Button) findViewById(R.id.btn_change);
        txtContent = (TextView) findViewById(R.id.txt_content);
        btnChange.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                new Thread(new Runnable() {
                    @Override
                    public void run() {
                        Message msg = new Message();//创建了一个Message（android.os.Message）对象
                        msg.what = UPDATE_TEXT;//将Message的what字段的值指定为UPDATE_TEXT
                        handler.sendMessage(msg);//调用Handler的sendMessage()方法将这条Message发送出去。
                    }
                }).start();
            }
        });
    }

    //注意此时handleMessage()方法中的代码就是在主线程当中运行的了，所以我们可以放心地在这里进行UI操作
    private Handler handler = new Handler() {//创建一个Handler对象
        @Override
        public void handleMessage(Message msg) {//重写父类的handleMessage方法，在这里对具体的Message进行处理。
            if (msg.what == UPDATE_TEXT) {
                txtContent.setText("Nice to meet you.");
            }
        }
    };

}

（3）解析异步消息处理机制
Android中的异步消息处理主要由四个部分组成，Message、Handler、MessageQueue和Looper。
1.Message
Message是在线程之间传递的消息，它可以在内部携带少量的信息，用于在不同线程之间交换数据。上一小节中我们使用到了Message的what字段，除此之外还可以使用arg1和arg2字段来携带一些整型数据，使用obj字段携带一个Object对象。

2.Handler
Handler顾名思义也就是处理者的意思，它主要是用于发送和处理消息的。发送消息一般是使用Handler的sendMessage()方法，而发出的消息经过一系列地辗转处理后，最终会传递到Handler的handleMessage()方法中。

3.MessageQueue
MessageQueue是消息队列的意思，它主要用于存放所有通过Handler发送的消息。这部分消息会一直存在于消息队列中，等待被处理。每个线程中只会有一个MessageQueue对象。

4.Looper
Looper是每个线程中的MessageQueue的管家，调用Looper的loop()方法后，就会进入到一个无限循环当中，然后每当发现MessageQueue中存在一条消息，就会将它取出，并传递到Handler的handleMessage()方法中。每个线程中也只会有一个Looper对象。

异步消息处理的整个流程：

* 首先需要在主线程当中创建一个Handler对象，并重写handleMessage()方法。
* 然后当子线程中需要进行UI操作时，就创建一个Message对象，并通过Handler将这条消息发送出去。
* 之后这条消息会被添加到MessageQueue的队列中等待被处理，而Looper则会一直尝试从MessageQueue中取出待处理消息，最后分发回Handler的handleMessage()方法中。由于Handler是在主线程中创建的，所以此时handleMessage()方法中的代码也会在主线程中运行，于是我们在这里就可以安心地进行UI操作了。

整个异步消息处理机制的流程示意图如下图所示。

一条Message经过这样一个流程的辗转调用后，也就从子线程进入到了主线程，从不能更新UI变成了可以更新UI，整个异步消息处理的核心思想也就是如此。

（4）使用AsyncTask
不过为了更加方便我们在子线程中对UI进行操作，Android还提供了另外一些好用的工具，AsyncTask就是其中之一。借助AsyncTask，即使你对异步消息处理机制完全不了解，也可以十分简单地从子线程切换到主线程。当然，AsyncTask背后的实现原理也是基于异步消息处理机制的，只是Android帮我们做了很好的封装而已。
首先来看一下AsyncTask的基本用法，由于AsyncTask是一个抽象类，所以如果我们想使用它，就必须要创建一个子类去继承它。在继承时我们可以为AsyncTask类指定三个泛型参数，这三个参数的用途如下。
1.Params
在执行AsyncTask时需要传入的参数，可用于在后台任务中使用。
2.Progress
后台任务执行时，如果需要在界面上显示当前的进度，则使用这里指定的泛型作为进度单位。
3.Result
当任务执行完毕后，如果需要对结果进行返回，则使用这里指定的泛型作为返回值类型。
因此，一个最简单的自定义AsyncTask就可以写成如下方式：

class DownloadTask extends AsyncTask<Void, Integer, Boolean> {
    ……
}

这里我们把AsyncTask的第一个泛型参数指定为Void，表示在执行AsyncTask的时候不需要传入参数给后台任务。第二个泛型参数指定为Integer，表示使用整型数据来作为进度显示单位。第三个泛型参数指定为Boolean，则表示使用布尔型数据来反馈执行结果。

当然，目前我们自定义的DownloadTask还是一个空任务，并不能进行任何实际的操作，我们还需要去重写AsyncTask中的几个方法才能完成对任务的定制。经常需要去重写的方法有以下四个。
1.onPreExecute()
这个方法会在后台任务开始执行之前调用，用于进行一些界面上的初始化操作，比如显示一个进度条对话框等。
2.doInBackground(Params…)
这个方法中的所有代码都会在子线程中运行，我们应该在这里去处理所有的耗时任务。任务一旦完成就可以通过return语句来将任务的执行结果返回，如果AsyncTask的第三个泛型参数指定的是Void，就可以不返回任务执行结果。注意，在这个方法中是不可以进行UI操作的，如果需要更新UI元素，比如说反馈当前任务的执行进度，可以调用publishProgress(Progress…)方法来完成。
3.onProgressUpdate(Progress…)
当在后台任务中调用了publishProgress(Progress…)方法后，这个方法就会很快被调用，方法中携带的参数就是在后台任务中传递过来的。在这个方法中可以对UI进行操作，利用参数中的数值就可以对界面元素进行相应地更新。
4.onPostExecute(Result)
当后台任务执行完毕并通过return语句进行返回时，这个方法就很快会被调用。返回的数据会作为参数传递到此方法中，可以利用返回的数据来进行一些UI操作，比如说提醒任务执行的结果，以及关闭掉进度条对话框等。
因此，一个比较完整的自定义AsyncTask就可以写成如下方式：

class DownloadTask extends AsyncTask<Void, Integer, Boolean> {

    @Override
    protected void onPreExecute() {
        progressDialog.show(); // 显示进度对话框
    }

//在doInBackground()方法里去执行具体的下载任务。这个方法里的代码都是在子线程中运行的，因而不会影响到主线程的运行。注意这里虚构了一个doDownload()方法，这个方法用于计算当前的下载进度并返回，我们假设这个方法已经存在了。在得到了当前的下载进度后，下面就该考虑如何把它显示到界面上了，由于 doInBackground()方法是在子线程中运行的，在这里肯定不能进行UI操作，所以我们可以调用publishProgress()方法并将当前的下载进度传进来，这样onProgressUpdate() 方法就会很快被调用，在这里就可以进行UI操作了。
    @Override
    protected Boolean doInBackground(Void... params) {
        try {
            while (true) {
                int downloadPercent = doDownload(); // 这是一个虚构的方法
                publishProgress(downloadPercent);
                if (downloadPercent >= 100) {
                    break;
                }
            }
        } catch (Exception e) {
            return false;
        }
        return true;
    }

    @Override
    protected void onProgressUpdate(Integer... values) {
          // 在这里更新下载进度

          progressDialog.setMessage(" Downloaded " + values[0] + "%");
    }

//当下载完成后，doInBackground()方法会返回一个布尔型变量，这样onPostExecute()方法就会很快被调用，这个方法也是在主线程中运行的。然后在这里我们会根据下载的结果来弹出相应的Toast提示，从而完成整个DownloadTask任务。
    @Override
    protected void onPostExecute(Boolean result) {
        progressDialog.dismiss(); // 关闭进度对话框
          // 在这里提示下载结果
        if (result) {
              Toast.makeText(context, "Download succeeded", Toast.LENGTH_SHORT).show();
        } else {
              Toast.makeText(context, " Download failed", Toast.LENGTH_SHORT).show();
        }
    }
}

简单来说，使用AsyncTask的诀窍就是，在doInBackground()方法中去执行具体的耗时任务，在onProgressUpdate()方法中进行UI操作，在onPostExecute()方法中执行一些任务的收尾工作。
如果想要启动这个任务，只需编写以下代码即可：

new DownloadTask().execute();

二、服务的基本用法

1、服务的基本用法

* 定义一个服务
* 启动和停止服务
* 活动和服务进行通信

下面按用一个Demo来说明以上三点：

布局文件：

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical">

    <Button
        android:id="@+id/btn_start"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="Start Service" />

    <Button
        android:id="@+id/btn_stop"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="Stop Service" />

    <Button
        android:id="@+id/btn_bind"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="Bind Service" />

    <Button
        android:id="@+id/btn_unbind"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="Unbind Service" />
</LinearLayout>

MyService类（服务）：

package com.test.service;

import android.app.Service;
import android.content.Intent;
import android.os.Binder;
import android.os.IBinder;
import android.support.annotation.Nullable;
import android.util.Log;

/**
* Created by Administrator on 2016/5/9 0009.
*/
public class MyService extends Service {
    private static final String TAG = "MyService";

    private DownloadBinder mBinder = new DownloadBinder();

    @Nullable
    @Override
    public IBinder onBind(Intent intent) {
        return mBinder;
    }

    class DownloadBinder extends Binder {

        public void startDownload() {
            Log.i(TAG, "startDownload executed");
        }

        public int getProgress() {
            Log.i(TAG, "getProgress executed");
            return 0;
        }
    }

    @Override
    public void onCreate() {//onCreate()方法会在服务创建的时候调用
        super.onCreate();
        Log.i(TAG, "onCreate executed");
    }

    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {//onStartCommand()方法会在每次服务启动的时候调用
        Log.i(TAG, "onStartCommand executed");
        return super.onStartCommand(intent, flags, startId);
    }

    @Override
    public void onDestroy() {//onDestroy()方法会在服务销毁的时候调用
        super.onDestroy();
        Log.i(TAG, "onDestroy executed");
    }
}

启动类：

package com.test.service;

import android.content.ComponentName;
import android.content.Intent;
import android.content.ServiceConnection;
import android.os.IBinder;
import android.support.v7.app.ActionBarActivity;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;

import com.test.R;

public class ServiceActivity extends ActionBarActivity implements View.OnClickListener {
    private Button btnStart, btnStop, btnBind, btnUnbind;
    private MyService.DownloadBinder downloadBinder;

    private ServiceConnection connection = new ServiceConnection() {//创建了一个ServiceConnection的匿名类
        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {//在活动与服务成功绑定的时候调用
            downloadBinder = (MyService.DownloadBinder) service;//得到了DownloadBinder的实例，有了这个实例，活动和服务之间的关系就变得非常紧密了。
            // 现在我们可以在活动中根据具体的场景来调用DownloadBinder中的任何public方法，即实现了指挥服务干什么，服务就去干什么的功能。
            downloadBinder.startDownload();
            downloadBinder.getProgress();
        }

        @Override
        public void onServiceDisconnected(ComponentName name) {//在活动与服务解除绑定的时候调用
        }
    };

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_service);
        initView();
    }

    private void initView() {
        btnStart = (Button) findViewById(R.id.btn_start);
        btnStop = (Button) findViewById(R.id.btn_stop);
        btnBind = (Button) findViewById(R.id.btn_bind);
        btnUnbind = (Button) findViewById(R.id.btn_unbind);
        btnStart.setOnClickListener(this);
        btnStop.setOnClickListener(this);
        btnBind.setOnClickListener(this);
        btnUnbind.setOnClickListener(this);
    }

    @Override
    public void onClick(View v) {
        switch (v.getId()) {
            case R.id.btn_start:
                Intent startIntent = new Intent(this, MyService.class);
                startService(startIntent);
                break;
            case R.id.btn_stop:
                Intent stopIntent = new Intent(this, MyService.class);
                stopService(stopIntent);
                break;
            case R.id.btn_bind:
                Intent bingIntent = new Intent(this, MyService.class);
                //bindService()方法接收三个参数，
                // 第一个参数就是刚刚构建出的Intent对象，
                // 第二个参数是前面创建出的ServiceConnection的实例，
                // 第三个参数则是一个标志位，这里传入BIND_AUTO_CREATE表示在活动和服务进行绑定后自动创建服务。
                // 这会使得MyService中的onCreate()方法得到执行，但onStartCommand()方法不会执行。
                bindService(bingIntent, connection, BIND_AUTO_CREATE);//绑定服务
                break;
            case R.id.btn_unbind:
                unbindService(connection);//解绑服务
                break;
        }
    }
}

最后别忘了要在清单文件中声明服务：

<application
    android:allowBackup="true"
    android:icon="@mipmap/ic_launcher"
    android:label="@string/app_name"
    android:supportsRtl="true"
    android:theme="@style/AppTheme">
    <activity android:name=".service.ServiceActivity">
        <intent-filter>
            <action android:name="android.intent.action.MAIN" />

            <category android:name="android.intent.category.LAUNCHER" />
        </intent-filter>
    </activity>

    <provider
        android:name=".database_contentprivoder.DatabaseProvider"
        android:authorities="com.test.database_contentprivoder.provider" />

    <service android:name=".service.MyService" />
</application>

另外需要注意，任何一个服务在整个应用程序范围内都是通用的，即MyService不仅可以和MainActivity绑定，还可以和任何一个其他的活动进行绑定，而且在绑定完成后它们都可以获取到相同的DownloadBinder实例。

2、服务的生命周期

使用前台服务
服务也有自己的生命周期，一旦在项目的任何位置调用了Context的startService()方法，相应的服务就会启动起来，并回调onStartCommand()方法。如果这个服务之前还没有创建过，onCreate()方法会先于onStartCommand()方法执行。服务启动了之后会一直保持运行状态，直到stopService()或stopSelf()方法被调用。注意虽然每调用一次startService()方法，onStartCommand()就会执行一次，但实际上每个服务都只会存在一个实例。所以不管你调用了多少次startService()方法，只需调用一次stopService()或stopSelf()方法，服务就会停止下来了。

另外，还可以调用Context的bindService()来获取一个服务的持久连接，这时就会回调服务中的onBind()方法。类似地，如果这个服务之前还没有创建过，onCreate()方法会先于onBind()方法执行。之后，调用方可以获取到onBind()方法里返回的IBinder对象的实例，这样就能自由地和服务进行通信了。只要调用方和服务之间的连接没有断开，服务就会一直保持运行状态。

当调用了startService()方法后，又去调用stopService()方法，这时服务中的onDestroy()方法就会执行，表示服务已经销毁了。类似地，当调用了bindService()方法后，又去调用unbindService()方法，onDestroy()方法也会执行，这两种情况都很好理解。但是需要注意，我们是完全有可能对一个服务既调用了startService()方法，又调用了bindService()方法的，这种情况下该如何才能让服务销毁掉呢？根据Android系统的机制，一个服务只要被启动或者被绑定了之后，就会一直处于运行状态，必须要让以上两种条件同时不满足，服务才能被销毁。所以，这种情况下要同时调用stopService()和unbindService()方法，onDestroy()方法才会执行。

三、服务的更多技巧

1、服务的更多技巧

如果你希望服务可以一直保持运行状态，而不会由于系统内存不足的原因导致被回收，就可以考虑使用前台服务。前台服务和普通服务最大的区别就在于，它会一直有一个正在运行的图标在系统的状态栏显示，下拉状态栏后可以看到更加详细的信息，非常类似于通知的效果。当然有时候你也可能不仅仅是为了防止服务被回收掉才使用前台服务的，有些项目由于特殊的需求会要求必须使用前台服务，比如说墨迹天气，它的服务在后台更新天气数据的同时，还会在系统状态栏一直显示当前的天气信息，如图下图所示。

代码就是在尚一个例子的基础上修改MyService中的onCreate()方法，其他地方没有改变。

public class MyService extends Service {
    ……
@Override
public void onCreate() {//onCreate()方法会在服务创建的时候调用
    super.onCreate();
    Log.i(TAG, "onCreate executed");
    Notification notification = new Notification(R.mipmap.ic_launcher, "Notification comes ", System.currentTimeMillis());
    Intent intent = new Intent(this, ServiceActivity.class);
    PendingIntent pendingIntent = PendingIntent.getActivity(this, 0, intent, 0);
    notification.setLatestEventInfo(this, "This is title.", "This is content.", pendingIntent);
    //调用startForeground()方法后就会让MyService变成一个前台服务，并在系统状态栏显示出来。这个方法接收两个参数，
    // 第一个参数是通知的id，类似于notify()方法的第一个参数，
    //第二个参数则是构建出的Notification对象。
    startForeground(1, notification);
}
    ……
}

2、使用IntentService

官方为了解决厦门两个问题专门提供了一个IntentService类，这两个问题分别是：

• 在服务里去处理一些耗时的逻辑，就很容易出现ANR（Application Not Responding）的情况；

• 服务一旦启动之后，就会一直处于运行状态，必须调用stopService()或者stopSelf()方法才能让服务停止下来，但是总会有一些程序员忘记开启线程，或者忘记调用stopSelf()方法。

  IntentService类可以简单地创建一个异步的、会自动停止的服务。下面举个例子，直接在上面代码中继续写。
  布局文件：

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical" >
    ……
    <Button
        android:id="@+id/start_intent_service"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="Start IntentService" />
</LinearLayout>

新增一个MyIntentService类：

package com.test.service;

import android.app.IntentService;
import android.content.Intent;
import android.util.Log;

/**
* Created by Administrator on 2016/5/11 0011.
*/
public class MyIntentService extends IntentService {

    private static final String TAG = "MyIntentService";

    public MyIntentService() {//提供一个无参构造函数
        super(TAG);//必须调用父类的有参构造函数
    }

    /**
    * 在这个方法中可以去处理一些具体的逻辑，而且不用担心ANR的问题，因为这个方法已经是在子线程中运行的了。
    *
    * @param intent
    */
    @Override
    protected void onHandleIntent(Intent intent) {
        Log.i(TAG, "Thread id is " + Thread.currentThread().getId());//打印当前线程的ID
    }

    @Override
    public void onDestroy() {
        super.onDestroy();
        Log.i(TAG, "onDestroy executed");
    }
}

修改启动类：

public class MainActivity extends Activity implements OnClickListener {
     ……
    private Button startIntentService;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        ……
        startIntentService = (Button) findViewById(R.id.start_intent_service);
        startIntentService.setOnClickListener(this);
    }

    @Override
    public void onClick(View v) {
        switch (v.getId()) {
        ……
        case R.id.start_intent_service:
            // 打印主线程的id

             Log.d("MainActivity", "Thread id is " + Thread.currentThread(). getId());
            Intent intentService = new Intent(this, MyIntentService.class);
            startService(intentService);
            break;
        default:
            break;
        }
    }
}

最后别忘了清单文件的声明：

<service android:name=".service.MyIntentService" />

四、服务的最佳实践——后台执行的定时任务

服务的最佳实践——后台执行的定时任务

在服务中经常用到的技术之一，在后台执行定时任务。
Android中的定时任务一般有两种实现方式，一种是使用Java API里提供的Timer类，一种是使用Android的Alarm机制。这两种方式在多数情况下都能实现类似的效果，但Timer有一个明显的短板，它并不太适用于那些需要长期在后台运行的定时任务。我们都知道，为了能让电池更加耐用，每种手机都会有自己的休眠策略，Android手机就会在长时间不操作的情况下自动让CPU进入到睡眠状态，这就有可能导致Timer中的定时任务无法正常运行。而Alarm机制则不存在这种情况，它具有唤醒CPU的功能，即可以保证每次需要执行定时任务的时候CPU都能正常工作。需要注意，这里唤醒CPU和唤醒屏幕完全不是同一个概念，千万不要产生混淆。
那么首先我们来看一下Alarm机制的用法吧，其实并不复杂，主要就是借助了AlarmManager类来实现的。这个类和NotificationManager有点类似，都是通过调用Context的getSystemService()方法来获取实例的，只是这里需要传入的参数是Context.ALARM_SERVICE。因此，获取一个AlarmManager的实例就可以写成：

AlarmManager manager = (AlarmManager) getSystemService(Context.ALARM_SERVICE);

接下来调用AlarmManager的set()方法就可以设置一个定时任务了，比如说想要设定一个任务在10秒钟后执行，就可以写成：

long triggerAtTime = SystemClock.elapsedRealtime() + 10 * 1000;

//set()方法中的参数说明：
//第一个参数是一个整型参数，用于指定AlarmManager的工作类型，有四种值可选，分别是ELAPSED_REALTIME、ELAPSED_REALTIME_WAKEUP、RTC和RTC_WAKEUP。
//其中ELAPSED_REALTIME表示让定时任务的触发时间从系统开机开始算起，但不会唤醒CPU。
//ELAPSED_REALTIME_WAKEUP同样表示让定时任务的触发时间从系统开机开始算起，但会唤醒CPU。
//RTC表示让定时任务的触发时间从1970年1月1日0点开始算起，但不会唤醒CPU。
//RTC_WAKEUP同样表示让定时任务的触发时间从1970年1月1日0点开始算起，但会唤醒CPU。
//使用SystemClock.elapsedRealtime()方法可以获取到系统开机至今所经历时间的毫秒数，
//使用System.currentTimeMillis()方法可以获取到1970年1月1日0点至今所经历时间的毫秒数。
//第二个参数是定时任务触发的时间，以毫秒为单位。
//如果第一个参数使用的是ELAPSED_REALTIME或ELAPSED_REALTIME_WAKEUP，则这里传入开机至今的时间再加上延迟执行的时间。
//如果第一个参数使用的是RTC或RTC_WAKEUP，则这里传入1970年1月1日0点至今的时间再加上延迟执行的时间。
//第三个参数是一个PendingIntent，对于它你应该已经不会陌生了吧。
//这里我们一般会调用getBroadcast()方法来获取一个能够执行广播的PendingIntent。这样当定时任务被触发的时候，广播接收器的onReceive()方法就可以得到执行。
manager.set(AlarmManager.ELAPSED_REALTIME_WAKEUP, triggerAtTime, pendingIntent);

下面是一个例子，首先创建一个可以长期在后台执行定时任务的服务LongRunningService类：

package com.test.service;

import android.app.AlarmManager;
import android.app.PendingIntent;
import android.app.Service;
import android.content.Intent;
import android.os.IBinder;
import android.os.SystemClock;
import android.support.annotation.Nullable;
import android.util.Log;

import java.util.Date;

/**
* Created by Administrator on 2016/5/11 0011.
*/
public class LongRunningService extends Service {
    private static final String TAG = "LongRunningService";

    @Nullable
    @Override
    public IBinder onBind(Intent intent) {
        return null;
    }

    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
//在onStartCommand()方法里开启了一个子线程，然后在子线程里就可以执行具体的逻辑操作了。
        new Thread() {
            @Override
            public void run() {
                Log.i(TAG, "executed at " + new Date().toString());
            }
        }.start();
        AlarmManager manager = (AlarmManager) getSystemService(ALARM_SERVICE);//获取到了AlarmManager的实例
        int anHour = 60 * 60 * 1000;//这是一小时的毫秒数
        long triggerAtTime = SystemClock.elapsedRealtime() + anHour;//定义任务的触发时间为一小时后
        Intent i = new Intent(this, AlarmReceiver.class);
        PendingIntent pi = PendingIntent.getBroadcast(this, 0, i, 0);//使用PendingIntent指定处理定时任务的广播接收器为AlarmReceiver
        manager.set(AlarmManager.ELAPSED_REALTIME_WAKEUP, triggerAtTime, pi);//调用set()方法完成设定
        return super.onStartCommand(intent, flags, startId);
    }
}

创建线程之后的代码就是我们刚刚讲解的Alarm机制的用法了，先是获取到了AlarmManager的实例，然后定义任务的触发时间为一小时后，再使用PendingIntent指定处理定时任务的广播接收器为AlarmReceiver，最后调用set()方法完成设定。下面是AlarmReceiver类：

package com.test.service;

import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;

/**
* Created by Administrator on 2016/5/11 0011.
*/
public class AlarmReceiver extends BroadcastReceiver {
    @Override
    public void onReceive(Context context, Intent intent) {
        Intent i = new Intent(context, LongRunningService.class);//构建出了一个Intent对象
        context.startService(i);//启动LongRunningService这个服务
    }
}

之后是启动类：

package com.test.service;

import android.content.Intent;
import android.support.v7.app.ActionBarActivity;
import android.os.Bundle;

public class LongServiceActivity extends ActionBarActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        Intent intent = new Intent(this,LongRunningService.class);
        startService(intent);
    }
}

最后是清单文件中的声明：

<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.example.servicebestpractice"
    android:versionCode="1"
    android:versionName="1.0" >
     ……
    <application
        android:allowBackup="true"
        android:icon="@drawable/ic_launcher"
        android:label="@string/app_name"
        android:theme="@style/AppTheme" >
        <activity
            android:name="com.example.servicebestpractice.MainActivity"
            android:label="@string/app_name" >
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>

        <service android:name=".LongRunningService" />

        <receiver android:name=".AlarmReceiver" />

    </application>
</manifest>

另外需要注意的是，从Android 4.4版本开始，Alarm任务的触发时间将会变得不准确，有可能会延迟一段时间后任务才能得到执行。这并不是个bug，而是系统在耗电性方面进行的优化。系统会自动检测目前有多少Alarm任务存在，然后将触发时间将近的几个任务放在一起执行，这就可以大幅度地减少CPU被唤醒的次数，从而有效延长电池的使用时间。当然，如果你要求Alarm任务的执行时间必须准备无误，Android仍然提供了解决方案。使用AlarmManager的setExact()方法来替代set()方法，就可以保证任务准时执行了。