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. }