服务（Service）是Android中实现程序后台运行的解决方案。它非常适合去执行那些不需要和用户交互而且还要求长期运行的任务。服务的运行不依赖于任何用户界面，即使程序被切换到后台，或者用户打开了另外一个应用程序，服务仍然能够保持正常运行。不过需要注意的是，服务并不是运行在一个独立的进程当中的，而是依赖于创建服务时所在的应用程序进程。当某个应用程序进程被杀掉时，所有依赖于该进程的服务也会停止运行。

另外，也不要被服务的后台概念所迷惑，实际上服务并不会自动开启线程，所有的代码都是默认运行在主线程当中的。也就是说，我们需要在服务的内部手动创建子线程，并在这里执行具体的任务，否则就有可能出现主线程被阻塞住的情况。

Android多线程编程

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

线程的基本用法

使用继承的方法实现多线程

定义一个线程只需要新建一个类继承自Thread ，然后重写父类的run() 方法，并在里面编写耗时逻辑即可，如下所示：

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

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

new MyThread().start();

使用实现Runnable 接口的方式来实现多线程

使用实现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();

在子线程中更新UI

和许多其他的GUI库一样，Android的UI也是线程不安全的。也就是说，如果想要更新应用程序里的UI元素，则必须在主线程中进行，否则就会出现异常。

新建一个AndroidThreadTest项目，希望在点击Button后可以把TextView中显示的Hello world字符串改成Nice to meet you。

然后修改activity_main.xml中的代码，如下所示：

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout 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=".MainActivity">

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

    <TextView
        android:id="@+id/show_text"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_centerInParent="true"
        android:text="Hello world"
        android:textSize="20sp" />


</RelativeLayout>

MainActivity中的代码，如下所示：

package com.example.androidthreadtest;

import androidx.appcompat.app.AppCompatActivity;

import android.os.Bundle;
import android.view.View;
import android.widget.Button;
import android.widget.TextView;

public class MainActivity extends AppCompatActivity implements View.OnClickListener{

    private TextView text;//应该为全局变量


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

        //实例化
        text=(TextView) findViewById(R.id.show_text);
        Button changeText= (Button)findViewById(R.id.change_text);
        changeText.setOnClickListener(this);
    }

    @Override
    public void onClick(View v){
        switch (v.getId()){
            case R.id.change_text:  //匿名类的方式实现多线程
                new Thread(new Runnable() {
                    @Override
                    public void run() {
                        // 处理具体的逻辑
                        text.setText("Nice to meet you");
                    }
                }).start();
                break;

            default:
                break;
        }
    }


}

运行结果如下所示

点击Change Text按钮，会发现程序果然崩溃了，如下图所示。

通过日志可以看出是由于在子线程中更新UI所导致的

Only the original thread that created a view hierarchy can touch its views.
at android.view.ViewRootImpl.checkThread(ViewRootImpl.java:8191)

“只有创建视图层次结构的原始线程才能接触其视图。”

由此证实了Android确实是不允许在子线程中进行UI操作的。但是有些时候，我们必须在子线程里去执行一些耗时任务，然后根据任务的执行结果来更新相应的UI控件。对于这种情况，Android提供了一套异步消息处理机制，完美地解决了在子线程中进行UI操作的问题。为此，将MainActivity中的代码改为如下所示

package com.example.androidthreadtest;

import androidx.appcompat.app.AppCompatActivity;

import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.view.View;
import android.widget.Button;
import android.widget.TextView;

public class MainActivity extends AppCompatActivity implements View.OnClickListener{

    private TextView text;//应该为全局变量

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

    //然后新增一个handler对象
    //并重写父类的handleMessage() 方法
    private Handler handler=new Handler(){

        public void handleMessage (Message msg) {
            switch (msg.what) {
                case UPDATE_TEXT: //如果发现Message的what 字段的值等于UPDATE_TEXT，就更改其中的TextView内容
                    //在这里可以进行UI操作
                    text.setText("Nice to meet you");
                    break;

                default:
                    break;
            }
        }
    };


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

        //实例化
        text=(TextView) findViewById(R.id.show_text);
        Button changeText= (Button)findViewById(R.id.change_text);
        changeText.setOnClickListener(this);
    }

    @Override
    public void onClick(View v){
        switch (v.getId()){
            case R.id.change_text:  //匿名类的方式实现多线程
                new Thread(new Runnable() {
                    @Override
//                    public void run() {
                        // 处理具体的逻辑
//                        text.setText("Nice to meet you");

                    //并没有在子线程里直接进行UI操作
                       public void run() {
                            Message message = new Message();//创建了一个Message （android.os.Message ）对象
                            message.what = UPDATE_TEXT;//将其中what的值指定为“UPDATE_TEXT”

                        //然后调用Handler 的sendMessage() 方法，来发送这条message
                            handler.sendMessage(message); // 将Message对象发送出去。然后就会跳到handleMessage() 方法中
                        //而handleMessage() 方法中的代码则是在主线程当中运行的。那么就不会报错了
                    }
                }).start();
                break;

            default:
                break;
        }
    }


}

这就是Android异步消息处理的基本用法，使用这种机制就可以出色地解决掉在子线程中更新UI的问题。

下面就来分析一下Android异步消息处理机制到底是如何工作的。

Android异步消息处理机制

Android中的异步消息处理主要由4个部分组成：Message、Handler、MessageQueue和Looper。（其中的Message和Handler我们上一节已经用过了）

Message

Message是在线程之间传递的消息，它可以在内部携带少量的信息，用于在不同线程之间交换数据。

Handler

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

MessageQueue

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

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。

使用AsyncTask

为了更加方便我们在子线程中对UI进行操作，android还提供了另外一些好用的工具。比如AsyncTask。借助AsyncTask，即使对异步消息处理机制完全不了解，也可以十分简单地从子线程切换到主线程。当然，AsyncTask背后的实现原理也是基于异步消息处理机制的，只是Android做了很好的封装而已。

首先来看一下AsyncTask的基本用法，由于AsyncTask是一个抽象类，所以如果我们想使用它，就必须要创建一个子类去继承它。在继承时我们可以为AsyncTask类指定3个泛型参数，这3个参数的用途如下。

Params 。在执行AsyncTask时需要传入的参数，可用于在后台任务中使用。
Progress 。后台任务执行时，如果需要在界面上显示当前的进度，则使用这里指定的泛型作为进度单位。
Result 。当任务执行完毕后，如果需要对结果进行返回，则使用这里指定的泛型作为返回值类型。

一个最简单的自定义AsyncTask就可以写成如下方式：

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

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

一般我们需要重写一下几个方法来完成对任务的定制

onPreExecute()

这个方法会在后台任务开始执行之前调用，用于进行一些界面上的初始化操作，比如显示一个进度条对话框等。

doInBackground(Params...)

这个方法中的所有代码都会在子线程中运行，我们应该在这里去处理所有的耗时任务。任务一旦完成就可以通过return 语句来将任务的执行结果返回，如果AsyncTask的第三个泛型参数指定的是Void ，就可以不返回任务执行结果。注意，在这个方法中是不可以进行UI操作的，如果需要更新UI元素，比如说反馈当前任务的执行进度，可以调用publishProgress (Progress...) 方法来完成。

onProgressUpdate(Progress...)

当在后台任务中调用了publishProgress(Progress...) 方法后，onProgressUpdate (Progress...) 方法就会很快被调用，该方法中携带的参数就是在后台任务中传递过来的。在这个方法中可以对UI进行操作，利用参数中的数值就可以对界面元素进行相应的更新。

onPostExecute(Result)

当后台任务执行完毕并通过return 语句进行返回时，这个方法就很快会被调用。返回的数据会作为参数传递到此方法中，可以利用返回的数据来进行一些UI操作，比如说提醒任务执行的结果，以及关闭掉进度条对话框等。

一个比较完整的自定义AsyncTask就可以写成如下方式：

class DownloadTask extends AsyncTask<Void, Integer, Boolean> {
    @Override
    protected void onPreExecute() {
        progressDialog.show(); // 显示进度对话框
    }
    @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] + "%");
    }
    @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();
        }
    }
}

在这个DownloadTask中，我们在doInBackground() 方法里去执行具体的下载任务。这个方法里的代码都是在子线程中运行的，因而不会影响到主线程的运行。注意这里虚构了一个doDownload() 方法，这个方法用于计算当前的下载进度并返回，我们假设这个方法已经存在了。在得到了当前的下载进度后，下面就该考虑如何把它显示到界面上了，由于doInBackground() 方法是在子线程中运行的，在这里肯定不能进行UI操作，所以我们可以调用publishProgress() 方法并将当前的下载进度传进来，这样onProgressUpdate() 方法就会很快被调用，在这里就可以进行UI操作了。
当下载完成后，doInBackground() 方法会返回一个布尔型变量，这样onPostExecute()方法就会很快被调用，这个方法也是在主线程中运行的。然后在这里我们会根据下载的结果来弹出相应的Toast提示，从而完成整个DownloadTask任务。
简单来说，使用AsyncTask的诀窍就是，在doInBackground() 方法中执行具体的耗时任务，在onProgressUpdate() 方法中进行UI操作，在onPostExecute() 方法中执行一些任务的收尾工作

如果想要启动这个任务，只需编写以下代码即可：

new DownloadTask().execute();

并不需要去考虑什么异步消息处理机制，也不需要专门使用一个Handler来发送和接收消息，只需要调用一下publishProgress() 方法，就可以轻松地从子线程切换到UI线程了。

服务的基本用法

定义一个服务

首先创建一个ServiceTest项目。然后右击com.example.servicetest→New→Service→Service，会弹出如下图所示的窗口。

可以看到，这里我们将服务命名为MyService，Exported 属性表示是否允许除了当前程序之外的其他程序访问这个服务，Enabled 属性表示是否启用这个服务。将两个属性都勾中，点击Finish完成创建。

现在观察MyService中的代码，如下所示：

package com.example.servicetest;

import android.app.Service;
import android.content.Intent;
import android.os.IBinder;

public class MyService extends Service { //继承自service类，说明这事一个服务
    public MyService() {
        
    }

    @Override
    public IBinder onBind(Intent intent) {//这是service中唯一一个抽象方法，所以必须在子类中实现
        // TODO: Return the communication channel to the service.
        throw new UnsupportedOperationException("Not yet implemented");
    }
}

MyService 是继承自Service 类的，说明这是一个服务。目前MyService 中可以算是空空如也，但有一个onBind() 方法特别醒目。这个方法是Service中唯一的一个抽象方法，所以必须要在子类里实现。我们会在后面的小节中使用到onBind() 方法，目前可以暂时将它忽略掉。
既然是定义一个服务，自然应该在服务中去处理一些事情了，那处理事情的逻辑应该写在哪里呢？这时就可以重写Service中的另外一些方法了，如下所示：

package com.example.servicetest;

import android.app.Service;
import android.content.Intent;
import android.os.IBinder;

public class MyService extends Service { //继承自service类，说明这事一个服务
    public MyService() {
        
    }

    @Override
    public IBinder onBind(Intent intent) {//这是service中唯一一个抽象方法，所以必须在子类中实现
        // TODO: Return the communication channel to the service.
        throw new UnsupportedOperationException("Not yet implemented");
    }

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



    //onStartCommand() 方法会在每次服务启动的时候调用
    //如果希望服务一旦启动就立刻去执行某个动作，就可以将逻辑写在这里
    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        return super.onStartCommand(intent, flags, startId);
    }
    
    
    
    //onDestroy() 方法会在服务销毁的时候调用。
    //在此处回收那些不再使用的资源
    @Override
    public void onDestroy() {
        super.onDestroy();
    }
    
}

打开AndroidManifest.xml文件，会发现代码已经写在里面了哈

启动和停止服务

启动和停止的方法，主要是借助Intent来实现的。首先修改activity_main.xml中的代码，如下所示：

<?xml version="1.0" encoding="utf-8"?>
<androidx.constraintlayout.widget.ConstraintLayout 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=".MainActivity">

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

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

</androidx.constraintlayout.widget.ConstraintLayout>

然后修改MainActivity中的代码，如下所示：

package com.example.servicetest;

import androidx.appcompat.app.AppCompatActivity;

import android.content.Intent;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;

public class MainActivity extends AppCompatActivity implements View.OnClickListener{

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

        //分别获取到了Start Service按钮和Stop Service按钮的实例
        Button startService =(Button) findViewById(R.id.start_service);
        Button stopService =(Button) findViewById(R.id.stop_service);

        //注册点击事件
        startService.setOnClickListener(this);
        stopService.setOnClickListener(this);
    }

    @Override
    public void onClick (View v){
        switch (v.getId()){
            case R.id.start_service://在按钮点击事件中，构建一个Intent对象
                Intent startIntent = new Intent (this, MyService.class);
                startService(startIntent);//启动服务
                break;
                
            case R.id.stop_service:
                Intent stopIntent=new Intent(this, MyService.class);
                stopService(stopIntent);//停止服务
                break;
                
            default:
                break;
        }
    }

}

注意，这里完全是由活动来决定服务何时停止的，如果没有点击Stop Service按钮，服务就会一直处于运行状态。那服务有没有什么办法让自已停止下来呢？当然可以，只需要在MyService的任何一个位置调用stopSelf() 方法就能让这个服务停止下来了。

MyService中代码如下：

package com.example.servicetest;

import android.app.Service;
import android.content.Intent;
import android.os.IBinder;
import android.util.Log;

public class MyService extends Service { //继承自service类，说明这事一个服务
    public MyService() {
        
    }

    @Override
    public IBinder onBind(Intent intent) {//这是service中唯一一个抽象方法，所以必须在子类中实现
        // TODO: Return the communication channel to the service.
        throw new UnsupportedOperationException("Not yet implemented");
    }

    
    
    //onCreate() 方法会在服务创建的时候调用
    @Override
    public void onCreate() {
        super.onCreate();
        Log.d("MyService", "onCreate executed");//加入打印日志
    }



    //onStartCommand() 方法会在每次服务启动的时候调用
    //如果希望服务一旦启动就立刻去执行某个动作，就可以将逻辑写在这里
    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        Log.d("MyService", "onStartCommand executed");//加入打印日志
        return super.onStartCommand(intent, flags, startId);
    }
    
    
    
    //onDestroy() 方法会在服务销毁的时候调用。
    //在此处回收那些不再使用的资源
    @Override
    public void onDestroy() {
        super.onDestroy();
        Log.d("MyService", "onDestroy executed");//加入打印日志
    }
    
}

运行代码。布局要改为线性布局

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:orientation="vertical"
    android:layout_width="match_parent"
    android:layout_height="match_parent">
    <Button
        android:id="@+id/start_service"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="Start Service" />
    <Button
        android:id="@+id/stop_service"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="Stop Service" />
</LinearLayout>

通过上面的demo。我们可以清楚的知道onDestroy()就是销毁服务。但是onCreate() 方法和onStartCommand() 方法到底有什么区别呢？在点击start service按钮后两个方法都执行了。

其实onCreate() 方法是在服务第一次创建的时候调用的，而onStartCommand() 方法则在每次启动服务的时候都会调用，由于刚才我们是第一次点击Start Service按钮，服务此时还未创建过，所以两个方法都会执行，之后如果你再连续多点击几次Start Service按钮，你就会发现只有onStartCommand() 方法可以得到执行了。

活动和服务进行通信

在上一节中，我们实现了通过活动来启动服务或停止服务。但是此后，服务并没有反馈信息到活动中。那么有没有什么办法能让活动和服务的关系更紧密一些呢？例如在活动中指挥服务去干什么，服务就去干什么。当然可以，这就需要借助我们前面提及到的onBind() 方法了。

希望在MyService里提供一个下载功能，然后在活动中可以决定何时开始下载，以及随时查看下载进度。实现这个功能的思路是创建一个专门的Binder 对象来对下载功能进行管理，修改MyService中的代码，如下所示：

package com.example.servicetest;

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

public class MyService extends Service { //继承自service类，说明这事一个服务

    //定义一个内部类，下载，继承自Binder
    class DownloadBinder extends Binder{

        //提供了开始下载以及查看下载进度的方法

        public void startDownload(){
            Log.d("MyService", "startDownload executed");
        }

        public int getProgress() {
            Log.d("MyService", "getProgress executed");
            return 0;
        }
    }

    //创建了DownloadBinder的实例
    private DownloadBinder mBinder= new DownloadBinder();


    public MyService() {
        
    }

    @Override
    public IBinder onBind(Intent intent) {//这是service中唯一一个抽象方法，所以必须在子类中实现
        // TODO: Return the communication channel to the service.
//        throw new UnsupportedOperationException("Not yet implemented");
        return mBinder;//在onBind() 方法里返回前面创建的DownloadBinder实例
    }

    
    
    //onCreate() 方法会在服务创建的时候调用
    @Override
    public void onCreate() {
        super.onCreate();
        Log.d("MyService", "onCreate executed");//加入打印日志
    }



    //onStartCommand() 方法会在每次服务启动的时候调用
    //如果希望服务一旦启动就立刻去执行某个动作，就可以将逻辑写在这里
    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        Log.d("MyService", "onStartCommand executed");//加入打印日志
        return super.onStartCommand(intent, flags, startId);
    }
    
    
    
    //onDestroy() 方法会在服务销毁的时候调用。
    //在此处回收那些不再使用的资源
    @Override
    public void onDestroy() {
        super.onDestroy();
        Log.d("MyService", "onDestroy executed");//加入打印日志
    }
    
}