参考
Android中的Service：默默的奉献者 (1)
Android中的Service：Binder，Messenger，AIDL（2）
service深入解析
Android中Service的使用详解和注意点（LocalService）
Android中Local Service最本质的作用是什么？
android后台服务service全解析(上)--service的使用与本地通信
android后台服务service全解析(下)--service远程通信
把Service等同于thread或process是一个非常常见的误解。需要强调又强调的第一点是，Android的Service是一个Context。和Activity这种活跃周期相对短暂的component对比而言，一旦用户切换到其他应用，当前Activity就必须pause, stop甚至被destroy，不能在后台处理其他事务。需要强调的事，严格来说你仍然可以在activity里创建自己的worker thread或async task之类做后台的事情，但这样做没有任何保障——因为一旦你所有的activity都被切换到了后台，系统随时可能kill掉你的process，你的后台任务随时可能悄无声息的死掉。
Activity为什么这样设计？Windows下面的窗口在最小化的时候不是一样可以处理消息或者继续运行吗？这是另外一个话题，不过回答也很简单：这是移动设备，内存/电池都有限。
对你的应用而言，通过在manifest里声明Service，把需要后台相对长期运行的逻辑放在Service里，你便获得了这样的保障：只要系统内存不是极端不够用，你的Service一定不会被kill掉。对系统而言，当看到一个进程里有Service在运行，这个进程就具有较高的优先级，会在内存不足被杀的行列里排得比较靠后。
可是前面不是强调了Service并不等于process或thread吗？为什么上面又在说杀进程什么的？这里再次强调，你可以把Service看成一砣代码，用来在后台做些事情，仅此而已。至于这砣代码在哪里运行，完全是取决于你自己的喜好。你的local service，如果不建立worker thread，仍然是在你的应用进程的主线程即UI线程里运行。如果你不想阻塞UI线程，你就建一个worker thread。但这些细节，Android framework并不怎么care，它只知道你声明了一个service，然后在你的manifest里面找到这个service是声明在哪个process里运行，那么这个process就不容易被kill。
什么时候选择local service（即不指定额外的进程），什么时候选择remote service（额外的进程）？通常我们会把真的需要长期运行的service（例如IM之类）放在单独的进程里，这样UI所在的进程在必要的时候仍然可以被系统kill掉来腾出内存。而local service通常用来处理一些需要短期运行但仍然超出activity活动周期的任务，打个比方，发送短信或彩信。这样的任务执行完以后，service就可以stop自己，仍然不妨碍整个UI进程被回收掉。
一、Service的基本概念（四大组件之一）
Service是Android中实现程序后台运行的解决方案，非常适合用于去执行哪些不需要和用户交互而且还要求长期运行的任务。不能运行在一个独立的进程当中，而是依赖与创建服务时所在的应用程序进程。当某个应用程序进程被杀掉时，所有依赖于该进程的服务也会停止运行。
Service可以在很多场合使用，比如播放多媒体的时候用户启动了其他Activity，此时要在后台继续播放；比如检测SD卡上文件的变化；比如在后台记录你的地理信息位置的改变等等，总之服务是藏在后台的。
另外，不要被服务的后台概念所迷惑，实际上服务并不会自动开启线程，所有的代码都是默认运行在主线程中的。也就是说，我们需要在服务内部手动创建子线程，并在里面执行具体的任务，否则就有可能出现主线程被阻塞住的情况。
二、定义Service
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 {
public static final String TAG = "MyService";
//第一次创建服务时调用
@Override
public void onCreate() {
super.onCreate();
Log.d(TAG, "onCreate");
}
//每次启动服务时调用
@Override
public int onStartCommand(Intent intent, int flags, int startId) {
Log.d(TAG, "onStartCommand");
return super.onStartCommand(intent, flags, startId);
}
//销毁服务时调用
@Override
public void onDestroy() {
super.onDestroy();
Log.d(TAG, "onDestroy");
}
@Override
public IBinder onBind(Intent intent) {
return null;
}
}
onCreate是第一次创建时调用，以后每次startService时调用onStartCommand,每次stopService时调用onDestory
三、启动和停止服务
定义好服务之后，接下来看一下如何启动和停止一个服务，这主要是借助Intent来实现的。注意startService()和stopService()方法都是定义在Context类当中的，所以可以在MainActivity中直接调用这两个方法。
package com.example.servicetest;
import android.app.Activity;
import android.content.Intent;
import android.os.Bundle;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
public class MainActivity extends Activity implements OnClickListener {
private Button button1_start_service;
private Button button2_stop_service;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
button1_start_service = (Button) findViewById(R.id.button1_start_service);
button2_stop_service = (Button) findViewById(R.id.button2_stop_service);
button1_start_service.setOnClickListener(this);
button2_stop_service.setOnClickListener(this);
}
@Override
public void onClick(View v) {
switch (v.getId()) {
case R.id.button1_start_service:
Intent startIntent = new Intent(this, MyService.class);
startService(startIntent);
break;
case R.id.button2_stop_service:
Intent stopIntent = new Intent(this, MyService.class);
stopService(stopIntent);
break;
default:
break;
}
}
}
需要注意的是：
- 服务对象同时只会有一个
- 默认情况下，一个started的Service与启动他的组件在同一个线程中。上面的实例中，服务就是在主线程中运行的，如果是在服务中完成耗时操作的话，容易造成主线程阻塞。
- 停止一个started服务有两种方法：
- 在外部使用stopService()
- 在服务内部(onStartCommand方法内部)使用stopSelf()方法。
四、活动和服务进行通信
有没有什么办法能让活动和服务的关联更多一些呢？比如说在Activity中指挥Service去干什么，Service就去干什么。当然可以，只需要借助onBind()方法。
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 {
public static final String TAG = "MyService";
private MyBinder mBinder = new MyBinder();
@Override
public void onCreate() {
super.onCreate();
Log.d(TAG, "onCreate");
}
@Override
public int onStartCommand(Intent intent, int flags, int startId) {
Log.d(TAG, "onStartCommand");
return super.onStartCommand(intent, flags, startId);
}
@Override
public void onDestroy() {
super.onDestroy();
Log.d(TAG, "onDestroy");
}
@Override
public IBinder onBind(Intent intent) {
return mBinder; //在这里返回新建的MyBinder类
}
//MyBinder类，继承Binder：让里面的方法执行下载任务，并获取下载进度
class MyBinder extends Binder {
public void startDownload() {
Log.d("TAG", "startDownload() executed");
// 执行具体的下载任务
}
public int getProgress(){
Log.d("TAG", "getProgress() executed");
return 0;
}
}
}
package com.example.servicetest;
import android.app.Activity;
import android.content.ComponentName;
import android.content.Intent;
import android.content.ServiceConnection;
import android.os.Bundle;
import android.os.IBinder;
import android.util.Log;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
public class MainActivity extends Activity implements OnClickListener {
private Button button1_start_service;
private Button button2_stop_service;
private Button button3_bind_service;
private Button button4_unbind_service;
private MyService.MyBinder myBinder;
//匿名内部类：服务连接对象
private ServiceConnection connection = new ServiceConnection() {
//当服务异常终止时会调用。注意，解除绑定服务时不会调用
@Override
public void onServiceDisconnected(ComponentName name) {
}
//和服务绑定成功后，服务会回调该方法
@Override
public void onServiceConnected(ComponentName name, IBinder service) {
myBinder = (MyService.MyBinder) service;
//在Activity中调用Service里面的方法
myBinder.startDownload();
myBinder.getProgress();
}
};
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
button1_start_service = (Button) findViewById(R.id.button1_start_service);
button2_stop_service = (Button) findViewById(R.id.button2_stop_service);
button3_bind_service = (Button) findViewById(R.id.button3_bind_service);
button4_unbind_service = (Button) findViewById(R.id.button4_unbind_service);
button1_start_service.setOnClickListener(this);
button2_stop_service.setOnClickListener(this);
button3_bind_service.setOnClickListener(this);
button4_unbind_service.setOnClickListener(this);
}
@Override
public void onClick(View v) {
switch (v.getId()) {
case R.id.button1_start_service:
Intent startIntent = new Intent(this, MyService.class);
startService(startIntent);
break;
case R.id.button2_stop_service:
Intent stopIntent = new Intent(this, MyService.class);
stopService(stopIntent);
break;
case R.id.button3_bind_service:
Intent bindIntent = new Intent(this, MyService.class);
bindService(bindIntent, connection, BIND_AUTO_CREATE);
break;
case R.id.button4_unbind_service:
unbindService(connection);
break;
default:
break;
}
}
}
可以看到，这里我们首先创建了一个ServiceConnection的匿名类（24行），在里面重写了onServiceConnected()方法和onServiceDisconnected()方法，如果当前Activity与服务连接成功后，服务会回调onServiceConnected()方法，
在onServiceConnected()方法中，我们又通过向下转型得到了MyBinder的实例（34行），有了这个实例，Activity和Service之间的关系就变得非常紧密了。现在我们可以在Activity中根据具体的场景来调用MyBinder中的任何public方法（36、37行），即实现了Activity指挥Service干什么Service就去干什么的功能。
当然，现在Activity和Service其实还没关联起来了呢，这个功能是在Bind Service按钮的点击事件里完成的。可以看到，这里我们仍然是构建出了一个Intent对象，然后调用bindService()方法将Activity和Service进行绑定。bindService()方法接收三个参数，第一个参数就是刚刚构建出的Intent对象，第二个参数是前面创建出的ServiceConnection的实例，第三个参数是一个标志位，这里传入BIND_AUTO_CREATE表示在Activity和Service建立关联后会自动创建Service（即使之前没有创建Service也没有关系），这会使得MyService中的onCreate()方法得到执行，但onStartCommand()方法不会执行。
然后如何我们想解除Activity和Service之间的关联怎么办呢？调用一下unbindService()方法就可以了，这也是Unbind Service按钮的点击事件里实现的逻辑。
另外需要注意，任何一个Service在整个应用程序范围内都是通用的，即MyService不仅可以和MainActivity建立关联，还可以和任何一个Activity建立关联，而且在建立关联时它们都可以获取到相同的MyBinder实例。
如果我们既点击了Start Service按钮，又点击了Bind Service按钮会怎么样呢？这个时候你会发现，不管你是单独点击Stop Service按钮还是Unbind Service按钮，Service都不会被销毁，必要将Unbind Service按钮和Stop Service按钮都点击一下（没有先后顺序），Service才会被销毁。也就是说，点击Stop Service按钮只会让Service停止，点击Unbind Service按钮只会让Service和Activity解除关联，一个Service必须要在既没有和任何Activity关联又处理停止状态的时候才会被销毁。
什么时候用startService什么时候用bindService?
这个其实可以通过它们的特点很轻松的得到结论：它们之间的主要区别其实体现在两点，能否交互，以及生命周期。所以很显然的，startService适合那种启动之后不显式停止它就永远在后台运行，并且不需要客户端与服务端交互的service。比方说一条专门拿来存数据到本地数据库的service，它就一直在后台等着有别的组件startService，然后把拿到的数据存入数据库，这就显然是用startService做的事情。而bindService呢，就适合那种可以交互的，可以掌控它什么时候停什么时候开始的。另外，如果有IPC的需求，那当然bindService是必不可少的了。
我们在上一篇博文里讲过，其实在大多数情况下，startService和bindService都是相辅相成的，它们并不是孤立的存在。比方说我这个时候要做一个音乐播放器，那么后台播放是肯定要的吧？总不能手机一熄屏音乐也没了。另外，控制音乐也是要的吧？什么上一首下一首播放暂停什么的。这不就强强联合了么？当然要注意的是，在这两种启动方式同时存在去启动一个service的时候，service的生命周期会发生变化，必须从两种方法的角度看service均停止才能真正停止。
五、IntentService
我们在第一段中就已经说了，服务中的代码默认运行在主线程中，如果直接在服务里执行一些耗时操作，容易造成ANR（Application Not Responding）异常，所以就需要用到多线程的知识了。
因此一个比较标准的服务可以这样写：
package com.example.servicetest;import android.app.Service;
import android.content.Intent;
import android.os.IBinder;public class MyService extends Service {
public static final String TAG = "MyService"; //服务执行的操作 @Override public int onStartCommand(Intent intent, int flags, int startId) { new Thread(new Runnable() { public void run() { //处理具体的逻辑 stopSelf(); //服务执行完毕后自动停止 } }).start(); return super.onStartCommand(intent, flags, startId); } @Override public IBinder onBind(Intent intent) { // TODO Auto-generated method stub return null; }}
需要注意的是，如果没有第17行的stopSelf()，服务一旦启动后，就会一直处于运行状态，必须调用stopService()或者stopSelf()方法才能让服务停止下来；所以我们添加了17行的stopSelf()，服务执行完毕后会自动停止。
虽说上面的这种写法并不复杂，但总会有一些程序猿忘记开启线程，或者忘记调用stopSelf()方法。为了可以简单地创建一个异步的、会自动停止的服务，Android专门提供了一个IntentService类，这个类就很好的解决了上面所提到的两种尴尬。另外，可以启动IntentService多次，而每一个耗时操作会以工作队列的方式在IntentService的onHandleIntent()回调方法中执行，并且每次只会执行一个工作线程，执行完第一个后，再执行第二个，以此类推。IntentService内部仍然是采用了HandlerThread来执行任务。
package com.example.servicetest;
import android.app.IntentService;
import android.content.Intent;
import android.util.Log;
public class MyIntentService extends IntentService{
public MyIntentService() {
super("MyIntentService");//调用父类有参构造函数。这里我们手动给服务起个名字为：MyIntentService
// TODO Auto-generated constructor stub
}
//该方法在会在一个单独的线程中执行，来完成工作任务。任务结束后，该Service自动停止
@Override
protected void onHandleIntent(Intent intent) {
// TODO Auto-generated method stub
for(int i = 0;i<3;i++) {
//打印当前线程的id
Log.d("MyIntentService","IntentService线程的id是："+Thread.currentThread().getId());
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
@Override
public void onDestroy() {
// TODO Auto-generated method stub
super.onDestroy();
Log.d("MyIntentService","onDestroy");
}
}
六、Service和Thread的关系
不少Android初学者都可能会有这样的疑惑，Service和Thread到底有什么关系呢？什么时候应该用Service，什么时候又应该用Thread？答案可能会有点让你吃惊，因为Service和Thread之间没有任何关系！
之所以有不少人会把它们联系起来，主要就是因为Service的后台概念。Thread我们大家都知道，是用于开启一个子线程，在这里去执行一些耗时操作就不会阻塞主线程的运行。而Service我们最初理解的时候，总会觉得它是用来处理一些后台任务的，一些比较耗时的操作也可以放在这里运行，这就会让人产生混淆了。但是，如果我告诉你Service其实是运行在主线程里的，你还会觉得它和Thread有什么关系吗？
其实，后台和子线程是两个完全不同的概念：
Android的后台就是指，它的运行是完全不依赖UI的。即使Activity被销毁，或者程序被关闭，只要进程还在，Service就可以继续运行。比如说一些应用程序，始终需要与服务器之间始终保持着心跳连接，就可以使用Service来实现。你可能又会问，Service既然是运行在主线程里，在这里一直执行着心跳连接，难道就不会阻塞主线程的运行吗？当然会，但是我们可以在Service中再创建一个子线程，然后在这里去处理耗时逻辑就没问题了。
既然在Service里也要创建一个子线程，那为什么不直接在Activity里创建呢？这是因为Activity很难对Thread进行控制，当Activity被销毁之后，就没有任何其它的办法可以再重新获取到之前创建的子线程的实例；而且在一个Activity中创建的子线程，另一个Activity无法对其进行操作。但是Service就不同了，所有的Activity都可以与Service进行关联，然后可以很方便地操作其中的方法，即使Activity被销毁了，之后只要重新与Service建立关联，就又能够获取到原有的Service中Binder的实例。因此，使用Service来处理后台任务，Activity就可以放心地finish，完全不需要担心无法对后台任务进行控制的情况。