Android 多線程及線程通訊

AsyncTask

AsyncTask，它使建立須要與用戶界面交互的長時間運行的任務變得更簡單。相對來講AsyncTask更輕量級一些，適用於簡單的異步處理，不須要藉助線程和Handler便可實現。 

AsyncTask是抽象類.AsyncTask定義了三種泛型類型 Params，Progress和Result。 

　　Params 啓動任務執行的輸入參數，好比HTTP請求的URL。 

　　Progress 後臺任務執行的百分比。 

　　Result 後臺執行任務最終返回的結果，好比String。 

    AsyncTask的執行分爲四個步驟，每一步都對應一個回調方法，這些方法不該該由應用程序調用，開發者須要作的就是實現這些方法。 

　　1) 子類化AsyncTask 

　　2) 實現AsyncTask中定義的下面一個或幾個方法 

onPreExecute(), 該方法將在執行實際的後臺操做前被UI thread調用。能夠在該方法中作一些準備工做，如在界面上顯示一個進度條。 

doInBackground(Params...), 將在onPreExecute 方法執行後立刻執行，該方法運行在後臺線程中。這裏將主要負責執行那些很耗時的後臺計算工做。能夠調用 publishProgress方法來更新實時的任務進度。該方法是抽象方法，子類必須實現。 

onProgressUpdate(Progress...),在publishProgress方法被調用後，UI thread將調用這個方法從而在界面上展現任務的進展狀況，例如經過一個進度條進行展現。 

onPostExecute(Result), 在doInBackground 執行完成後，onPostExecute 方法將被UI thread調用，後臺的計算結果將經過該方法傳遞到UI thread. 

爲了正確的使用AsyncTask類，如下是幾條必須遵照的準則： 

　　1) Task的實例必須在UI thread中建立 

　　2) execute方法必須在UI thread中調用 

　　3)不要手動的調用onPreExecute(), onPostExecute(Result)，doInBackground(Params...), onProgressUpdate(Progress...)這幾個方法 

　　4)該task只能被執行一次，不然屢次調用時將會出現異常 

doInBackground方法和onPostExecute的參數必須對應，這兩個參數在AsyncTask聲明的泛型參數列表中指定，第一個爲doInBackground接受的參數，第二個爲顯示進度的參數，第第三個爲doInBackground返回和onPostExecute傳入的參數。

能夠調用cancel(boolean)去取消一個任務，在cancel(boolean)調用後，isCancelled()會返回true，而且在doInBackground(Object[])調用後會當即調用onCancelled(Object)，而不會去調用onPostExecute(Object)。在調用cancel(boolean)時，若是線程尚未開始執行，那麼線程不會去運行；若是線程已經開始運行了，那麼mayInterruptIfRunning 標誌決定了線程會否應該被中斷。所以咱們在doInBackground(Object[])中應該按期的檢查isCancelled()的值，以保證線程可以快速的中斷。

[html] view plaincopy

1. package com.example.asynctask;  

2.   

3. import java.io.IOException;  

4.   

5. import org.apache.http.HttpResponse;  

6. import org.apache.http.client.ClientProtocolException;  

7. import org.apache.http.client.HttpClient;  

8. import org.apache.http.client.methods.HttpGet;  

9. import org.apache.http.impl.client.DefaultHttpClient;  

10.   

11. import android.os.AsyncTask;  

12. import android.os.Bundle;  

13. import android.app.Activity;  

14. import android.view.Menu;  

15. import android.view.View;  

16. import android.view.View.OnClickListener;  

17. import android.widget.Button;  

18. import android.widget.ImageView;  

19. import android.widget.ProgressBar;  

20. import android.widget.Toast;  

21. import android.graphics.Bitmap;  

22. import android.graphics.BitmapFactory;  

23.   

24. public class Main_Activity extends Activity {  

25.       

26.     private ImageView  m_imageView;  

27.     private Button m_button;  

28.     private Button m_but;  

29.     private ProgressBar m_proBar;  

30.       

31.     Task task;  

32.   

33.     @Override  

34.     protected void onCreate(Bundle savedInstanceState) {  

35.         super.onCreate(savedInstanceState);  

36.         setContentView(R.layout.activity_main);  

37.           

38.         m_imageView = (ImageView)findViewById(R.id.imageView);  

39.         m_button = (Button)findViewById(R.id.download_btn);  

40.         m_proBar = (ProgressBar)findViewById(R.id.progressBar);  

41.         m_but = (Button)findViewById(R.id.cancel_btn);  

42.           

43.         task = null;  

44.         m_button.setOnClickListener(new OnClickListener()  

45.         {  

46.   

47.             @Override  

48.             public void onClick(View v) {  

49.                 // TODO Auto-generated method stub  

50.                 task = new Task();  

51.                 task.execute("http://www.baidu.com/img/shouye_b5486898c692066bd2cbaeda86d74448.gif");  

52.             }  

53.               

54.         });  

55.         m_but.setOnClickListener(new OnClickListener()  

56.         {  

57.   

58.             @Override  

59.             public void onClick(View v) {  

60.                 // TODO Auto-generated method stub  

61.                 task.cancel(false);  

62.             }  

63.         });  

64.     }  

65.   

66.     @Override  

67.     public boolean onCreateOptionsMenu(Menu menu) {  

68.         // Inflate the menu; this adds items to the action bar if it is present.  

69.         getMenuInflater().inflate(R.menu.main_, menu);  

70.         return true;  

71.     }  

72.       

73.     class Task extends AsyncTask<String,Integer,Bitmap>{  

74.   

75.         @Override  

76.         protected Bitmap doInBackground(String... params) {//處理後臺執行的任務，在後臺線程執行  

77.             // TODO Auto-generated method stub  

78.   

79.             publishProgress(0);//將會調用onProgressUpdate(Integer... progress)方法    

80.             HttpClient hc = new DefaultHttpClient();  

81.             publishProgress(30);  

82.             HttpGet hg = new HttpGet(params[0]);  

83.             Bitmap bm = null;                 

84.               

85.             HttpResponse hr = null;  

86.               

87.             try {  

88.                 Thread.currentThread().sleep(1000);  

89.             } catch (InterruptedException e1) {  

90.                 // TODO Auto-generated catch block  

91.                 e1.printStackTrace();  

92.             }  

93.             if(isCancelled())  

94.                 return null;  

95.               

96.             try {  

97.                 hr = hc.execute(hg);  

98.                 bm = BitmapFactory.decodeStream(hr.getEntity().getContent());  

99.             } catch (ClientProtocolException e) {  

100.                 // TODO Auto-generated catch block  

101.                 e.printStackTrace();  

102.             } catch (IOException e) {  

103.                 // TODO Auto-generated catch block  

104.                 e.printStackTrace();  

105.             }  

106.             if(isCancelled())  

107.                 return null;  

108.               

109.             publishProgress(100);  

110.             return bm;  

111.         }  

112.           

113.         protected void onProgressUpdate(Integer... progress) {//在調用publishProgress以後被調用，在ui線程執行  

114.             m_proBar.setProgress(progress[0]);    

115.         }    

116.           

117.         protected void onPostExecute(Bitmap result) {//後臺任務執行完以後被調用，在ui線程執行    

118.             if(result != null) {    

119.                 Toast.makeText(Main_Activity.this, "成功獲取圖片", Toast.LENGTH_LONG).show();    

120.                 m_imageView.setImageBitmap(result);    

121.             }else {    

122.                 Toast.makeText(Main_Activity.this, "獲取圖片失敗", Toast.LENGTH_LONG).show();    

123.                 m_proBar.setProgress(0);  

124.             }  

125.             publishProgress(0);  

126.         }    

127.             

128.         protected void onPreExecute () {//在 doInBackground(Params...)以前被調用，在ui線程執行    

129.             m_imageView.setImageBitmap(null);    

130.             m_proBar.setProgress(0);//進度條復位    

131.         }    

132.             

133.         protected void onCancelled () {//在ui線程執行    

134.             m_proBar.setProgress(0);//進度條復位    

135.             Toast.makeText(Main_Activity.this, "取消加載", Toast.LENGTH_LONG).show();  

136.         }    

137.           

138.     };  

139.   

140. }  

在程序中使用了網絡，所以須要在AndroidManifest.xml添加

[html] view plaincopy

1. <uses-permission android:name="android.permission.INTERNET"></uses-permission>  

Handler

Looper 是消息隊列的管理者，消息循環

Handler 是消息的處理者

Message 消息

MessageQueue 消息隊列

Handler 只可以關聯一個線程的Looper，一個Looper只能管理一個MessageQueue。能夠經過關聯的Handler向線程發送Message或者Runnable到消息隊列中。

[html] view plaincopy

1. package com.example.handlemsg;  

2.   

3. import android.os.Bundle;  

4. import android.os.Handler;  

5. import android.os.HandlerThread;  

6. import android.os.Looper;  

7. import android.os.Message;  

8. import android.annotation.SuppressLint;  

9. import android.app.Activity;  

10. import android.util.Log;  

11. import android.view.Menu;  

12. import android.view.View;  

13. import android.widget.Button;  

14. import android.widget.TextView;  

15.   

16. public class MainActivity extends Activity {  

17.       

18.     TextView tv;  

19.     Button but1;  

20.     Button but2;  

21.     MyHandler hd, subHd;  

22.     HandlerThread sub;  

23.   

24.     @Override  

25.     protected void onCreate(Bundle savedInstanceState) {  

26.         super.onCreate(savedInstanceState);  

27.         setContentView(R.layout.activity_main);  

28.           

29.         tv = (TextView)findViewById(R.id.tv);  

30.         but1 = (Button)findViewById(R.id.button1);  

31.         but2 = (Button)findViewById(R.id.button2);  

32.         hd = new MyHandler();  

33.           

34.         but1.setOnClickListener(new View.OnClickListener() {  

35.               

36.             @Override  

37.             public void onClick(View v) {  

38.                 // TODO Auto-generated method stub  

39.                 //給主線程本身發送一條消息  

40.                 hd.sendEmptyMessage(0);  

41.             }  

42.         });  

43.           

44.         but2.setOnClickListener(new View.OnClickListener() {  

45.               

46.             @Override  

47.             public void onClick(View v) {  

48.                 // TODO Auto-generated method stub  

49.                 //新建一個帶有Looper的線程  

50.                 sub = new HandlerThread("sub-thread");   

51.                 sub.start();  

52.                   

53.                 //給子線程關聯Handler,併發送一條消息給子線程  

54.                 subHd = new MyHandler(sub.getLooper());  

55.                 subHd.sendEmptyMessage(0);  

56.                   

57.                 //給子線程發送一個Runnable，在Runnable中發送一條消息給主線程  

58.                 subHd.post(new Runnable(){  

59.   

60.                     @Override  

61.                     public void run() {  

62.                         // TODO Auto-generated method stub  

63.                         //發送一條消息給主線程  

64.                         hd.sendEmptyMessage(0);  

65.                     }  

66.                       

67.                 });  

68.             }  

69.         });  

70.           

71.         //終止子線程  

72.         //subHd.getLooper().quit();  

73.     }  

74.       

75.     @SuppressLint("HandlerLeak")  

76.     class MyHandler extends Handler{  

77.           

78.         public MyHandler() {  

79.             // TODO Auto-generated constructor stub  

80.             super();  

81.         }  

82.           

83.         public MyHandler(Looper looper) {  

84.             // TODO Auto-generated constructor stub  

85.             super(looper);  

86.         }  

87.   

88.         public void handleMessage(Message msg){  

89.             switch(msg.what)  

90.             {  

91.             case 0:  

92.                 Log.d(Thread.currentThread().getName(), "msg 0");  

93.                 break;  

94.             case 1:  

95.                 Log.d(Thread.currentThread().getName(), "msg 1");  

96.                 break;  

97.             default:  

98.                 Log.d(Thread.currentThread().getName(), "msg default");  

99.                 break;  

100.             }  

101.         }//handlemsg  

102.           

103.     }//MyHandler  

104.   

105. }  

synchronized

1.  synchronized 方法控制對類成員變量的訪問：每一個類實例對應一把鎖，每一個 synchronized 方法都必須得到調用該方法的類實例的鎖方能執行，不然所屬線程阻塞，方法一旦執行，就獨佔該鎖，直到從該方法返回時纔將鎖釋放，此後被阻塞的線程方能得到該鎖，從新進入可執行狀態。這種機制確保了同一時刻對於每個類實例，其全部聲明爲 synchronized 的成員函數中至多隻有一個處於可執行狀態（由於至多隻有一個可以得到該類實例對應的鎖），從而有效避免了類成員變量的訪問衝突（只要全部可能訪問類成員變量的方法均被聲明爲 synchronized）。  

2. synchronized 塊是這樣一個代碼塊，其中的代碼必須得到對象 syncObject （如前所述，能夠是類實例或類）的鎖方能執行。因爲能夠針對任意代碼塊，且可任意指定上鎖的對象，故靈活性較高。  

對synchronized(this)的一些理解 

1、當兩個併發線程訪問同一個對象object中的這個synchronized(this)同步代碼塊時，一個時間內只能有一個線程獲得執行。另外一個線程必須等待當前線程執行完這個代碼塊之後才能執行該代碼塊。  

2、然而，當一個線程訪問object的一個synchronized(this)同步代碼塊時，另外一個線程仍然能夠訪問該object中的非synchronized(this)同步代碼塊。  

3、尤爲關鍵的是，當一個線程訪問object的一個synchronized(this)同步代碼塊時，其餘線程對object中全部其它synchronized(this)同步代碼塊的訪問將被阻塞。  

4、當一個線程訪問object的一個synchronized(this)同步代碼塊時，它就得到了這個object的對象鎖。結果，其它線程對該object對象全部同步代碼部分的訪問都被暫時阻塞。

參考：http://blog.csdn.net/cjjky/article/details/7353390