Android之Service与IntentService的比较

不知道你们有没有和我同样，之前作项目或者练习的时候一直都是用Service来处理后台耗时操做，却不多注意到还有个IntentService，前段时间准备面试的时候看到了一篇关于IntentService的解释，发现了它相对于Service来讲有不少更加方便之处，今天在这里稍微来总结下个人心得。

    首先IntentService是继承自Service的，那咱们先看看Service的官方介绍，这里列出两点比较重要的地方：

      1.A Service is not a separate process. The Service object itself does not imply it is running in its own process; unless otherwise specified, it runs in the same process as the application it is part of.

      2.A Service is not a thread. It is not a means itself to do work off of the main thread (to avoid Application Not Responding errors).

      稍微翻一下(英文水平通常)

      1.Service不是一个单独的进程 ，它和应用程序在同一个进程中。

      2.Service不是一个线程，因此咱们应该避免在Service里面进行耗时的操做

关于第二点我想说下，不知道不少网上的文章都把耗时的操做直接放在Service的onStart方法中，并且没有强调这样会出现Application Not Responding！但愿个人文章能帮你们认清这个误区(Service不是一个线程，不能直接处理耗时的操做)。

       有人确定会问，那么为何我不直接用Thread而要用Service呢？关于这个，你们能够网上搜搜，这里不过多解释。有一点须要强调，若是有耗时操做在Service里，就必须开启一个单独的线程来处理！！！这点必定要铭记在心。 

       IntentService相对于Service来讲，有几个很是有用的优势，首先咱们看看官方文档的说明：

         IntentService is a base class for Services that handle asynchronous requests (expressed as Intents) on demand. Clients send requests throughstartService(Intent) calls; the service is started as needed, handles each Intent in turn using a worker thread, and stops itself when it runs out of work.

         This "work queue processor" pattern is commonly used to offload tasks from an application's main thread. The IntentService class exists to simplify this pattern and take care of the mechanics. To use it, extend IntentService and implement onHandleIntent(Intent). IntentService will receive the Intents, launch a worker thread, and stop the service as appropriate.

         All requests are handled on a single worker thread -- they may take as long as necessary (and will not block the application's main loop), but only one request will be processed at a time.

            稍微翻译理一理，这里主要是说IntentService使用队列的方式将请求的Intent加入队列，而后开启一个worker thread(线程)来处理队列中的Intent，对于异步的startService请求，IntentService会处理完成一个以后再处理第二个，每个请求都会在一个单独的worker thread中处理，不会阻塞应用程序的主线程，这里就给咱们提供了一个思路，若是有耗时的操做与其在Service里面开启新线程还不如使用IntentService来处理耗时操做。下面给一个小例子：

       1.Service：

[java] view plain copy print ?

1. package com.zhf.service; 
2.  
3. import android.app.Service; 
4. import android.content.Intent; 
5. import android.os.IBinder; 
6.  
7. public class MyService extends Service { 
8.  
9.     @Override 
10.     public void onCreate() { 
11.         super.onCreate(); 
12.     } 
13.      
14.     @Override 
15.     public void onStart(Intent intent, int startId) { 
16.         super.onStart(intent, startId); 
17.         //经测试，Service里面是不能进行耗时的操做的，必需要手动开启一个工做线程来处理耗时操做 
18.         System.out.println("onStart"); 
19.         try { 
20.             Thread.sleep(20000); 
21.         } catch (InterruptedException e) { 
22.             e.printStackTrace(); 
23.         } 
24.         System.out.println("睡眠结束"); 
25.     } 
26.      
27.     @Override 
28.     public IBinder onBind(Intent intent) { 
29.         return null; 
30.     } 
31. } 

package com.zhf.service;

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

public class MyService extends Service {

	@Override
	public void onCreate() {
		super.onCreate();
	}
	
	@Override
	public void onStart(Intent intent, int startId) {
		super.onStart(intent, startId);
		//经测试，Service里面是不能进行耗时的操做的，必需要手动开启一个工做线程来处理耗时操做
		System.out.println("onStart");
		try {
			Thread.sleep(20000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println("睡眠结束");
	}
	
	@Override
	public IBinder onBind(Intent intent) {
		return null;
	}
}

           2.IntentService：

[java] view plain copy print ?

1. package com.zhf.service; 
2.  
3. import android.app.IntentService; 
4. import android.content.Intent; 
5.  
6. public class MyIntentService extends IntentService { 
7.  
8.     public MyIntentService() { 
9.         super("yyyyyyyyyyy"); 
10.     } 
11.  
12.     @Override 
13.     protected void onHandleIntent(Intent intent) { 
14.         // 经测试，IntentService里面是能够进行耗时的操做的 
15.         //IntentService使用队列的方式将请求的Intent加入队列，而后开启一个worker thread(线程)来处理队列中的Intent 
16.         //对于异步的startService请求，IntentService会处理完成一个以后再处理第二个 
17.         System.out.println("onStart"); 
18.         try { 
19.             Thread.sleep(20000); 
20.         } catch (InterruptedException e) { 
21.             e.printStackTrace(); 
22.         } 
23.         System.out.println("睡眠结束"); 
24.     } 
25. } 

package com.zhf.service;

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

public class MyIntentService extends IntentService {

	public MyIntentService() {
		super("yyyyyyyyyyy");
	}

	@Override
	protected void onHandleIntent(Intent intent) {
		// 经测试，IntentService里面是能够进行耗时的操做的
		//IntentService使用队列的方式将请求的Intent加入队列，而后开启一个worker thread(线程)来处理队列中的Intent
		//对于异步的startService请求，IntentService会处理完成一个以后再处理第二个
		System.out.println("onStart");
		try {
			Thread.sleep(20000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println("睡眠结束");
	}
}

测试主程序：

[java] view plain copy print ?

1. package com.zhf.service; 
2.  
3. import android.app.Activity; 
4. import android.content.Intent; 
5. import android.os.Bundle; 
6.  
7. public class ServiceDemoActivity extends Activity { 
8.     /** Called when the activity is first created. */ 
9.     @Override 
10.     public void onCreate(Bundle savedInstanceState) { 
11.         super.onCreate(savedInstanceState); 
12.         setContentView(R.layout.main); 
13.         startService(new Intent(this,MyService.class));//主界面阻塞，最终会出现Application not responding 
14.         //连续两次启动IntentService，会发现应用程序不会阻塞，并且最重的是第二次的请求会再第一个请求结束以后运行(这个证明了IntentService采用单独的线程每次只从队列中拿出一个请求进行处理) 
15.         startService(new Intent(this,MyIntentService.class)); 
16.         startService(new Intent(this,MyIntentService.class)); 
17.     } 
18. }