Android 多线程处理之多线程用法大集合

原文：http://blog.youkuaiyun.com/jie1991liu/article/details/16961701

handler.post(r)其实这样并不会新起线程，只是执行的runnable里的run()方法，却没有执行start()方法，所以runnable走的还是UI线程。

1.如果像这样，是可以操作ui,但是run还是走在主线程，见打印出来的Log线程名字是main，说明是主线程。

这就是为什么可以直接在run方法里操作ui,因为它本质还是ui线程

handler.post(new Runnable(){

　　public void run(){

　　Log.e("当前线程：",Thread.currrentThread.getName());//这里打印de结果会是main

　　setTitle("哈哈");

      }

});

 

2.通过HandlerThread获取到looper却是可以新起线程，但是在这里的run方法里操作ui是不可能的，但是这显然有个缺点，如果你执行多次post(r)方法其实走的还是HandlerThread线程。假如你执行5次，n次，其实还是一次并且它们是串行的。假如下载5张图片，你会看到图片是下完第一张，才会去下第二张。

实践证明，只有是拥有主线程looper的handler才可以操作ui,而在主线程操作ui可以在handler的handlerMessage()方法中操作Ui,也可以在handler的post(r)的run方法里操作Ui.

HandlerThread ht = new HandlerThread("handler thread");

ht.start();

handler = new Handler(ht.getLooper());

handler.post(new Runnable(){//这里run()方法其实还是在等ht.start()调用

　　public void run(){

　　Log.e("当前线程：",Thread.currrentThread.getName());//这里打印的会是handler thread

　　setTitle("哈哈");//这样必定报错

　　//Android.view.ViewRoot$CalledFromWrongThreadException: Only the original thread that created a view hierarchy can touch its views.

      }

});

这样该怎么办呢，呵呵，可以无参构建一个handler。用这个handler来发送消息和处理消息，用上面的handler来开启新线程。

mainHandler = new Handler(){

　　protecket void handlerMessage(Message msg){

　　　　setTitle("哈哈");//这样就不会报错啦

　　}

}

handler.post(new Runnable(){//这里run()方法其实还是在等ht.start()调用

　　public void run(){

　　Log.e("当前线程：",Thread.currrentThread.getName());//这里打印的会是handler thread

　　mainHandler.sendEmpetMessage();//用mainHandler来发送消息

　　//setTitle("哈哈");//这样必定报错

　　//android.view.ViewRoot$CalledFromWrongThreadException: Only the original thread that created a view hierarchy can touch its views.

      }

});

打印Log:

3.其实第2个方法显得麻烦而且低效，用了2个handler，一个用来发起线程，一个用于处理消息。发起线程的handler必须拥有looper，所以还要实例化一个HanderThread；而处理消息的handler则不需要looper，因为它默认拥有主线程的looper，所以可以在这个handler处理ui。

其实可以只需要实例化一个handler，在主线程里构建一个无参的handler，然后由它发送和处理消息。而创建线程的任务就不用handler了，直接用new Thread(r).start();然后在r的run()方法里面处理逻辑事务。

用这样的模式下载5张图片，你就可能不会看到图片一张挨着一张展示出来，可能第2张先出来，也可能同时出来3张，5条线程很随机的。

[java]  view plain  copy

 

1. private void loadImagesByThread(final String url,final int id){//通过Thread来new 出多个线程  
2.           
3.         new Thread(new Runnable(){  
4.   
5.             @Override  
6.             public void run() {  
7.                 // TODO Auto-generated method stub  
8.                 Log.e("当前线程：", ""+Thread.currentThread().getName());  
9.                 Drawable drawable = null;  
10.                 try {  
11.                     drawable = Drawable.createFromStream(new URL(url).openStream(), "image.gif");  
12.                 } catch (MalformedURLException e) {  
13.                     // TODO Auto-generated catch block  
14.                     e.printStackTrace();  
15.                 } catch (IOException e) {  
16.                     // TODO Auto-generated catch block  
17.                     e.printStackTrace();  
18.                 }  
19.                 Message msg = mainHandler.obtainMessage();  
20.                 msg.what = 2012;  
21.                 msg.arg1 = id;  
22.                 msg.obj = drawable;  
23.                 msg.sendToTarget();  
24.                   
25.             }  
26.               
27.         }).start();  
28.     }  

打印Log:

4.AsyncTask

用异步任务架构多任务模型其实也不是很健壮，得创建多个AsyncTask实例。一个AsyncTask仅执行一次，不能重复执行，快餐类的线程，一次用完。

实现AsyncTask子类，最重要的两个方法，一个是doInBackground(params);一个是onPostExecute(result)。在doInBackground()方法里处理耗时事务，并把结果返回，返回的值将在onPostExecute方法作为参数，然后就可以在onPostExecute()把结果展示在ui上面了。

步骤：

①实例化AsyncTask：

实例化AsyncTask然后通过task.exec(pamas);传进去参数，这个参数列表是动态的，可以是一个也可以使多个，长度可变。

　　AsyncTask<params,values,reslut>,第一个参数会传进去这个方法doInBackground(params)，第二个参数是数据更新的值，第三个是处理事务返回的结果。

②onPreExecute方法：

这个方法没有参数，也没有返回值，可以在这个方法里，做一些提醒。比如show一个Dialog，或者弹个Toast告诉用户开始下载啦。

 

③doInBackground(params)方法:

进入AsyncTask内部结构，首先将执行reslut doInBackground(params)方法，这个方法将处理耗时事务，exec()的参数将会传进这个方法做参数，而返回值将会作为onPostExecute()的参数。如果要更新进度的话，需执行publicProgress()方法。

 

④onProgressUpdate(values)方法：

这个方法的参数必须在doInBackground()方法里执行publicProgress()方法，这个方法将会把参数传递进onProgressUpdate()方法里，然后可以在这个方法做一些ui上的更新展示，比如进度条的值就可以通过这个values值动态改变。

⑤onPostExecute(result)方法：

这里就是事务处理完毕的走的方法，doInBackground方法执行的结果将传到这里，如果这个方法返回了数据。在这个方法里可以处理Ui，可以把处理完的数据展示在ui上。比如图片啊，文字啊，一切你想要的结果。

[java]  view plain  copy

 

1. private void loadImageByAsyncTask(final String url,final int id){//构建异步任务，这样就不用handler来处理消息了  
2.         DownloadTask task = new DownloadTask();  
3.         task.execute(""+id,url);//AsyncTask不可重复执行  
4.     }  
5.       
6.     class DownloadTask extends AsyncTask<String,Integer,Drawable>{  
7.   
8.         int id;  
9.         @Override  
10.         protected Drawable doInBackground(String... params) {//params保存url和控件id两个数据  
11.             // TODO Auto-generated method stub  
12.             Log.e("当前线程：", ""+Thread.currentThread().getName());  
13.             Drawable drawable = null;  
14.             this.id = Integer.parseInt(params[0]);  
15.             try {  
16.                 drawable = Drawable.createFromStream(new URL(params[1]).openStream(), "image.gif");  
17.             } catch (MalformedURLException e) {  
18.                 // TODO Auto-generated catch block  
19.                 e.printStackTrace();  
20.             } catch (IOException e) {  
21.                 // TODO Auto-generated catch block  
22.                 e.printStackTrace();  
23.             }  
24.               
25.             return drawable;  
26.         }  
27.   
28.         @Override  
29.         protected void onPostExecute(Drawable result) {  
30.             // TODO Auto-generated method stub  
31.             super.onPostExecute(result);  
32.             ((ImageView)MainActivity.this.findViewById(id)).setImageDrawable(result);  
33.         }  
34.   
35.         @Override  
36.         protected void onPreExecute() {  
37.             // TODO Auto-generated method stub  
38.             super.onPreExecute();  
39.         }  
40.   
41.         @Override  
42.         protected void onProgressUpdate(Integer... values) {  
43.             // TODO Auto-generated method stub  
44.             super.onProgressUpdate(values);  
45.         }  
46.   
47.           
48.     }  

这里打印的log

 

5.ExecutorServie线程池

通过Executors的静态方法来创建，一般有三种：

1.单线程 ：Executors.newSingleThreadExecutor();

2.固定数量线程 ：Executors.newFixedThreadPool();

3.动态线程 ：Executors.newCachedThreadPool();

这里我们用固定5个线程来应用，使用方法是创建ExecutorService对象，然后执行submit(r)可以发起一个Runnable对象。用线程池来管理的好处是，可以保证系统稳定运行，适用与有大量线程，高工作量的情景下使用，假如要展示1000张图片如果创建1000个线程去加载，保证系统会死掉。用线程池就可以避免这个问题，可以用5个线程轮流执行，5个一组，执行完的线程不直接回收而是等待下次执行，这样对系统的开销就可以减小不少。

[java]  view plain  copy

 

1. private void loadImagesByExecutors(final String url,final int id){  
2.         service.submit(new Runnable(){  
3.               
4.             @Override  
5.             public void run() {  
6.                 // TODO Auto-generated method stub  
7.                 Log.e("当前线程：", ""+Thread.currentThread().getName());  
8.                   
9.                 try {  
10.                     final Drawable drawable  = Drawable.createFromStream(new URL(url).openStream(), "image.gif");  
11.                     mainHandler.post(new Runnable(){  
12.   
13.                         @Override  
14.                         public void run() {//这将在主线程运行  
15.                             // TODO Auto-generated method stub  
16.                             ((ImageView)MainActivity.this.findViewById(id)).setImageDrawable(drawable);  
17.                         }  
18.                     });  
19.                       
20.                 } catch (MalformedURLException e) {  
21.                     // TODO Auto-generated catch block  
22.                     e.printStackTrace();  
23.                 } catch (IOException e) {  
24.                     // TODO Auto-generated catch block  
25.                     e.printStackTrace();  
26.                 }  
27.                   
28.             }  
29.               
30.         });  
31.           
32.     }  

Log:

 

其实可能没有说清楚，第一种不算多线程。

1.loadImagesByHandler()是通过Handler.post()方法，构建两个Handler进行通信。

2.loadImagesByThread()，这个是直接new Thread()发起线程，在主线程的handler处理消息

3.loadImageByAsyncTask(),这个用的是异步任务，所有实现在它的内部结构里，可以在里头操作Ui.

4.loadImagesByExecutors()用的是线程池，使得线程可控，保证稳定运行。

其实常用的就是后三种，第二个用法灵活，简单，但不适宜大数量任务；第三个一般适用于单个任务，一次性任务；第四个一般用于大数量，高密度执行的使用情景，比如批量加载图片，批量下载文件等。

 

看一眼图吧：

 

全部源码：

[java]  view plain  copy

 

1. package com.bvin.exec;  
2.   
3. import java.io.IOException;  
4. import java.net.MalformedURLException;  
5. import java.net.URL;  
6. import java.util.concurrent.ExecutorService;  
7. import java.util.concurrent.Executors;  
8.   
9. import android.app.Activity;  
10. import android.graphics.drawable.Drawable;  
11. import android.os.AsyncTask;  
12. import android.os.Bundle;  
13. import android.os.Handler;  
14. import android.os.HandlerThread;  
15. import android.os.Message;  
16. import android.util.Log;  
17. import android.view.View;  
18. import android.widget.Button;  
19. import android.widget.ImageView;  
20.   
21. public class MainActivity extends Activity {  
22.     /** Called when the activity is first created. */  
23.       
24.     private Handler handler ;  
25.     private Button bt;  
26.     private Handler mainHandler = new Handler(){  
27.   
28.         @Override  
29.         public void handleMessage(Message msg) {  
30.             // TODO Auto-generated method stub  
31.             super.handleMessage(msg);  
32.             if(msg.what == 2012){  
33.                 //只要在主线程就可以处理ui   
34.                 ((ImageView)MainActivity.this.findViewById(msg.arg1)).setImageDrawable((Drawable)msg.obj);  
35.             }  
36.         }  
37.           
38.           
39.     };  
40.       
41.     private ExecutorService service = Executors.newFixedThreadPool(5);  
42.       
43.     @Override  
44.     public void onCreate(Bundle savedInstanceState) {  
45.         super.onCreate(savedInstanceState);  
46.         setContentView(R.layout.main);  
47.         initViews();  
48.         HandlerThread ht = new HandlerThread("down image thread");  
49.         ht.start();  
50.         handler = new Handler(ht.getLooper()){//如果有了looper那么这个handler就不可以处理ui了  
51.   
52.             @Override  
53.             public void handleMessage(Message msg) {  
54.                 // TODO Auto-generated method stub  
55.                 super.handleMessage(msg);  
56.                   
57.                   
58.             }  
59.               
60.         };  
61.           
62.     }  
63.       
64.     private void initViews(){  
65.           
66.         bt = (Button)findViewById(R.id.bt);  
67.         bt.setOnClickListener(new View.OnClickListener() {  
68.               
69.             @Override  
70.             public void onClick(View v) {  
71.                 // TODO Auto-generated method stub  
72.                 loadImagesByExecutors("http://news.baidu.com/z/resource/r/image/2012-11-23/23c1625aca99f02c50d8e510383a34e7.jpg",R.id.iv1);  
73.                 loadImagesByExecutors("http://news.baidu.com/z/resource/r/image/2012-11-23/c4698d97ef6d10722c8e917733c7beb3.jpg",R.id.iv2);  
74.                 loadImagesByExecutors("http://news.baidu.com/z/resource/r/image/2012-11-23/f332ffe433be2a3112be15f78bff5a40.jpg",R.id.iv3);  
75.                 loadImagesByExecutors("http://news.baidu.com/z/resource/r/image/2012-11-23/6ff8a9c647a1e80bc602eeda48865d4c.jpg",R.id.iv4);  
76.                 loadImagesByExecutors("http://news.baidu.com/z/resource/r/image/2012-11-23/f104d069f7443dca52a878d779392874.jpg",R.id.iv5);  
77.             }  
78.         });  
79.     }  
80.       
81.     private void loadImagesByHandler(final String url,final int id){//通过拥有looper的handler.post(runnable)，新建线程  
82.           
83.           
84.         handler.post(new Runnable(){//如果handler没有Looper那么它就不能构建新线程了  
85.   
86.             @Override  
87.             public void run() {  
88.                 // TODO Auto-generated method stub  
89.                 Log.e("当前线程：", ""+Thread.currentThread().getName());  
90.                 Drawable drawable = null;  
91.                 try {  
92.                     drawable = Drawable.createFromStream(new URL(url).openStream(), "image.gif");  
93.                 } catch (MalformedURLException e) {  
94.                     // TODO Auto-generated catch block  
95.                     e.printStackTrace();  
96.                 } catch (IOException e) {  
97.                     // TODO Auto-generated catch block  
98.                     e.printStackTrace();  
99.                 }  
100.                 //SystemClock.sleep(2000);  
101.                 //((ImageView)MainActivity.this.findViewById(id)).setImageDrawable(drawable);  
102.                 Message msg = mainHandler.obtainMessage();  
103.                 msg.what = 2012;  
104.                 msg.arg1 = id;  
105.                 msg.obj = drawable;  
106.                 msg.sendToTarget();  
107.             }  
108.               
109.         });  
110.           
111.           
112.     }  
113.       
114.     private void loadImagesByThread(final String url,final int id){//通过Thread来new 出多个线程  
115.           
116.         new Thread(new Runnable(){  
117.   
118.             @Override  
119.             public void run() {  
120.                 // TODO Auto-generated method stub  
121.                 Log.e("当前线程：", ""+Thread.currentThread().getName());  
122.                 Drawable drawable = null;  
123.                 try {  
124.                     drawable = Drawable.createFromStream(new URL(url).openStream(), "image.gif");  
125.                 } catch (MalformedURLException e) {  
126.                     // TODO Auto-generated catch block  
127.                     e.printStackTrace();  
128.                 } catch (IOException e) {  
129.                     // TODO Auto-generated catch block  
130.                     e.printStackTrace();  
131.                 }  
132.                 Message msg = mainHandler.obtainMessage();  
133.                 msg.what = 2012;  
134.                 msg.arg1 = id;  
135.                 msg.obj = drawable;  
136.                 msg.sendToTarget();  
137.                   
138.             }  
139.               
140.         }).start();  
141.     }   
142.   
143.     private void loadImageByAsyncTask(final String url,final int id){//构建异步任务，这样就不用handler来处理消息了  
144.         DownloadTask task = new DownloadTask();  
145.         task.execute(""+id,url);//AsyncTask不可重复执行  
146.     }  
147.       
148.     private void loadImagesByExecutors(final String url,final int id){  
149.         service.submit(new Runnable(){  
150.               
151.             @Override  
152.             public void run() {  
153.                 // TODO Auto-generated method stub  
154.                 Log.e("当前线程：", ""+Thread.currentThread().getName());  
155.                   
156.                 try {  
157.                     final Drawable drawable  = Drawable.createFromStream(new URL(url).openStream(), "image.gif");  
158.                     mainHandler.post(new Runnable(){  
159.   
160.                         @Override  
161.                         public void run() {//这将在主线程运行  
162.                             // TODO Auto-generated method stub  
163.                             ((ImageView)MainActivity.this.findViewById(id)).setImageDrawable(drawable);  
164.                         }  
165.                     });  
166.                       
167.                 } catch (MalformedURLException e) {  
168.                     // TODO Auto-generated catch block  
169.                     e.printStackTrace();  
170.                 } catch (IOException e) {  
171.                     // TODO Auto-generated catch block  
172.                     e.printStackTrace();  
173.                 }  
174.                   
175.             }  
176.               
177.         });  
178.           
179.     }  
180.       
181.     class DownloadTask extends AsyncTask<String,Integer,Drawable>{  
182.   
183.         int id;  
184.         @Override  
185.         protected Drawable doInBackground(String... params) {//params保存url和控件id两个数据  
186.             // TODO Auto-generated method stub  
187.             Log.e("当前线程：", ""+Thread.currentThread().getName());  
188.             Drawable drawable = null;  
189.             this.id = Integer.parseInt(params[0]);  
190.             try {  
191.                 drawable = Drawable.createFromStream(new URL(params[1]).openStream(), "image.gif");  
192.             } catch (MalformedURLException e) {  
193.                 // TODO Auto-generated catch block  
194.                 e.printStackTrace();  
195.             } catch (IOException e) {  
196.                 // TODO Auto-generated catch block  
197.                 e.printStackTrace();  
198.             }  
199.               
200.             return drawable;  
201.         }  
202.   
203.         @Override  
204.         protected void onPostExecute(Drawable result) {  
205.             // TODO Auto-generated method stub  
206.             super.onPostExecute(result);  
207.             ((ImageView)MainActivity.this.findViewById(id)).setImageDrawable(result);  
208.         }  
209.   
210.         @Override  
211.         protected void onPreExecute() {  
212.             // TODO Auto-generated method stub  
213.             super.onPreExecute();  
214.         }  
215.   
216.         @Override  
217.         protected void onProgressUpdate(Integer... values) {  
218.             // TODO Auto-generated method stub  
219.             super.onProgressUpdate(values);  
220.         }  
221.   
222.           
223.     }  
224. }