Android线程模型解析（包括UI的更新）

1.  
2. 1引言   
3.   
4. Android一词本义指机器人，Google于2007年11月发布了以Android命名的开源移动设备综合平台，包括其基于Linux的操作系统、中间件和关键的手机应用。并且组建了开放手机联盟，其成员囊括了全球著名的各大手机生产商和移动运营商。2008年8月，Google又发布了网上应用商店Android Market。任何一个开发者只需要借助Android发布的SDK开发手机应用，即可把开发的应用在Android Market上销售。目前Android Market上已经有一万多的应用程序，大大丰富了Android手机用户的功能。一个完整的产业链已经形成。因此开源Android吸引了原来越多的开发人员加入进来。本文将跟读者一起学习Android的线程模型。   
5.   
6. 2 Android进程   
7.   
8. 在了解Android线程之间得先了解一下Android的进程。当一个程序第一次启动的时候，Android会启动一个LINUX进程和一个主线程。默认的情况下，所有该程序的组件都将在该进程和线程中运行。同时，Android会为每个应用程序分配一个单独的LINUX用户。Android会劲量保留一个正在运行进程，只在内存资源出现不足时，Android会参试停止一些进程从而释放足够的资源给其他新的进程使用，也能保证用户正在访问的当前进程有足够的资源去及时的响应用户的事件。Android会根据进程中运行的组件类别以及组件的状态来判断该进程的重要性，Android会首先停止那些不重要的进程。按照重要性从高到低一共有五个级别：   
9.   
10. l  前台进程   
11.   
12. 前台进程是用户当前正在使用的进程。只有一些前台进程可以在任何时候都存在。他们是最后一个被结束的，当内存低到根本连他们都不能运行的时候。一般来说，在这种情况下，设备会进行内存调度，中止一些前台进程来保持对用户交互的响应。   
13.   
14. l  可见进程   
15.   
16. 可见进程不包含前台的组件但是会在屏幕上显示一个可见的进程是的重要程度很高，除非前台进程需要获取它的资源，不然不会被中止。   
17.   
18. l  服务进程   
19.   
20. 运行着一个通过startService() 方法启动的service，这个service不属于上面提到的2种更高重要性的。service所在的进程虽然对用户不是直接可见的，但是他们执行了用户非常关注的任务（比如播放mp3，从网络下载数据）。只要前台进程和可见进程有足够的内存，系统不会回收他们。   
21.   
22. l  后台进程   
23.   
24. 运行着一个对用户不可见的activity（调用过 onStop() 方法).这些进程对用户体验没有直接的影响，可以在服务进程、可见进程、前台进程需要内存的时候回收。通常，系统中会有很多不可见进程在运行，他们被保存在LRU (least recently used) 列表中，以便内存不足的时候被第一时间回收。如果一个activity正确的执行了它的生命周期，关闭这个进程对于用户体验没有太大的影响。   
25.   
26. l  空进程   
27.   
28. 未运行任何程序组件。运行这些进程的唯一原因是作为一个缓存，缩短下次程序需要重新使用的启动时间。系统经常中止这些进程，这样可以调节程序缓存和系统缓存的平衡。   
29.   
30. Android 对进程的重要性评级的时候，选取它最高的级别。另外，当被另外的一个进程依赖的时候，某个进程的级别可能会增高。一个为其他进程服务的进程永远不会比被服务的进程重要级低。因为服务进程比后台activity进程重要级高，因此一个要进行耗时工作的activity最好启动一个service来做这个工作，而不是开启一个子进程――特别是这个操作需要的时间比activity存在的时间还要长的时候。例如，在后台播放音乐，向网上上传摄像头拍到的图片，使用service可以使进程最少获取到“服务进程”级别的重要级，而不用考虑activity目前是什么状态。broadcast receivers做费时的工作的时候，也应该启用一个服务而不是开一个线程。   
31.   
32.  2单线程模型   
33.   
34.     当一个程序第一次启动时，Android会同时启动一个对应的主线程（Main Thread），主线程主要负责处理与UI相关的事件，如：用户的按键事件，用户接触屏幕的事件以及屏幕绘图事件，并把相关的事件分发到对应的组件进行处理。所以主线程通常又被叫做UI线程。在开发Android应用时必须遵守单线程模型的原则： Android UI操作并不是线程安全的并且这些操作必须在UI线程中执行。   
35.   
36. 2.1 案例演示   
37.   
38. 如果在没有理解这样的单线程模型的情况下，设计的程序可能会使程序性能低下，因为所有的动作都在同一个线程中触发。例如当主线程正在做一些比较耗时的操作的时候，如正从网络上下载一个大图片，或者访问数据库，由于主线程被这些耗时的操作阻塞住，无法及时的响应用户的事件，从用户的角度看会觉得程序已经死掉。如果程序长时间不响应，用户还可能得重启系统。为了避免这样的情况，Android设置了一个5秒的超时时间，一旦用户的事件由于主线程阻塞而超过5秒钟没有响应，Android会弹出一个应用程序没有响应的对话框。下面将通过一个案例来演示这种情况：   
39.   
40. 本程序将设计和实现查看指定城市的当天天气情况的功能，   
41.   
42. 1.  首先，需要选择一个天气查询的服务接口，目前可供选择的接口很多，诸如YAHOO的天气API和Google提供的天气API。本文将选择GOOGLE 的天气查询API。该接口提供了多种查询方式，可以通过指定具体城市的经纬度进行查询，也可以通过城市名称进行查询。   
43.   
44. 2.  用户在输入框内输入需要查询的城市名称，然后点击查询按钮   
45.   
46. 3.  当用户点击查询按钮后，使用已经内置在Android SDK中的HttpClient API来调用GOOGLE 的天气查询API，然后解析返回的指定城市的天气信息，并把该天气信息显示在Title上   
47.   
48. 主要代码如下：   
49.   
50. public class WeatherReport extends Activity implements OnClickListener {   
51.   
52.     private static final String GOOGLE_API_URL = "http://www.google.com/ig/api?weather=";   
53.   
54.     private static final String NETWORK_ERROR = "网络异常";   
55.   
56.     private EditText editText;   
57.   
58.     @Override  
59.   
60.     public void onCreate(Bundle savedInstanceState) {   
61.   
62.         super.onCreate(savedInstanceState);   
63.   
64.         setContentView(R.layout.main);   
65.   
66.         editText = (EditText) findViewById(R.id.weather_city_edit);   
67.   
68.         Button button = (Button) findViewById(R.id.goQuery);   
69.   
70.         button.setOnClickListener(this);   
71.   
72.     }   
73.   
74.     @Override  
75.   
76.     public void onClick(View v) {   
77.   
78.         //获得用户输入的城市名称   
79.   
80.         String city = editText.getText().toString();   
81.   
82.         //调用Google 天气API查询指定城市的当日天气情况   
83.   
84.         String weather = getWetherByCity(city);   
85.   
86.         //把天气信息显示在title上   
87.   
88.         setTitle(weather);   
89.   
90.     }   
91.   
92.        
93.   
94.     public String getWetherByCity(String city) {   
95.   
96.         HttpClient httpClient = new DefaultHttpClient();   
97.   
98.         HttpContext localContext = new BasicHttpContext();   
99.   
100.         HttpGet httpGet = new HttpGet(GOOGLE_API_URL + city);   
101.   
102.         try {   
103.   
104.             HttpResponse response = httpClient.execute(httpGet, localContext);   
105.   
106.             if (response.getStatusLine().getStatusCode() != HttpStatus.SC_OK) {   
107.   
108.                 httpGet.abort();   
109.   
110.             } else {   
111.   
112.                 HttpEntity httpEntity = response.getEntity();   
113.   
114.                 return parseWeather(httpEntity.getContent());   
115.   
116.             }   
117.   
118.         } catch (Exception e) {   
119.   
120.             Log.e("WeatherReport", "Failed to get weather", e);   
121.   
122.         } finally {   
123.   
124.             httpClient.getConnectionManager().shutdown();   
125.   
126.         }   
127.   
128.         return NETWORK_ERROR;   
129.   
130.     }   
131.   
132. }   
133.   
134. 当用户输入城市名称，然后单击按钮进行查询后，程序会调用Google API的接口获得指定城市的当日天气情况。由于需要访问网络，所以当网络出现异常或者服务繁忙的时候都会使访问网络的动作很耗时。本文为了要演示超时的现象，只需要制造一种网络异常的状况，最简单的方式就是断开网络连接，然后启动该程序，同时触发一个用户事件，比如按一下MENU键，由于主线程因为网络异常而被长时间阻塞，所以用户的按键事件在5秒钟内得不到响应，Android会提示一个程序无法响应的异常。    
135.   
136. 该对话框会询问用户是继续等待还是强行退出程序。当你的程序需要去访问未知的网络的时候都会可能会发生类似的超时的情况，用户的响应得不到及时的回应会大大的降低用户体验。所以我们需要参试以别的方式来实现   
137.   
138. 2.1 子线程更新UI   
139.   
140.     显然如果你的程序需要执行耗时的操作的话，如果像上例一样由主线程来负责执行该操作是错误的。所以我们需要在onClick方法中创建一个新的子线程来负责调用GOOGLE API来获得天气数据。刚接触Android的开发者最容易想到的方式就是如下：   
141.   
142.     public void onClick(View v) {   
143.   
144.        //创建一个子线程执行耗时的从网络上获取天气信息的操作   
145.   
146.        new Thread() {   
147.   
148.            @Override  
149.   
150.            public void run() {   
151.   
152.               //获得用户输入的城市名称   
153.   
154.               String city = editText.getText().toString();   
155.   
156.               //调用Google 天气API查询指定城市的当日天气情况   
157.   
158.               String weather = getWetherByCity(city);   
159.   
160.               //把天气信息显示在title上   
161.   
162.               setTitle(weather);   
163.   
164.            }   
165.   
166.        }.start();   
167.   
168.     }   
169.   
170. 但是很不幸，你会发现Android会提示程序由于异常而终止。为什么在其他平台上看起来很简单的代码在Android上运行的时候依然会出错呢？如果你观察LogCat中打印的日志信息就会发现这样的错误日志：   
171.   
172. android.view.ViewRoot$CalledFromWrongThreadException: Only the original thread that created a view hierarchy can touch its views.   
173.   
174. 从错误信息不难看出Android禁止其他子线程来更新由UI thread创建的试图。本例中显示天气信息的title实际是就是一个由UI thread所创建的TextView，所以参试在一个子线程中去更改TextView的时候就出错了。这显示违背了单线程模型的原则：Android UI操作并不是线程安全的并且这些操作必须在UI线程中执行   
175.   
176. 2.2 Message Queue   
177.   
178. 在单线程模型下，为了解决类似的问题，Android设计了一个Message Queue(消息队列)，线程间可以通过该Message Queue并结合Handler和Looper组件进行信息交换。下面将对它们进行分别介绍：   
179.   
180. l  Message Queue   
181.   
182. Message Queue是一个消息队列，用来存放通过Handler发布的消息。消息队列通常附属于某一个创建它的线程，可以通过Looper.myQueue()得到当前线程的消息队列。Android在第一启动程序时会默认会为UI thread创建一个关联的消息队列，用来管理程序的一些上层组件，activities，broadcast receivers 等等。你可以在自己的子线程中创建Handler与UI thread通讯。   
183.   
184. Handler   
185.   
186. 通过Handler你可以发布或者处理一个消息或者是一个Runnable的实例。每个Handler都会与唯一的一个线程以及该线程的消息队列管理。当你创建一个新的Handler时候，默认情况下，它将关联到创建它的这个线程和该线程的消息队列。也就是说，如果你通过Handler发布消息的话，消息将只会发送到与它关联的这个消息队列，当然也只能处理该消息队列中的消息。   
187.   
188. 主要的方法有：   
189.   
190. 1)   public final boolean sendMessage(Message msg)   
191.   
192. 把消息放入该Handler所关联的消息队列，放置在所有当前时间前未被处理的消息后。   
193.   
194. 2)   public void handleMessage(Message msg)   
195.   
196. 关联该消息队列的线程将通过调用Handler的handleMessage方法来接收和处理消息，通常需要子类化Handler来实现handleMessage。   
197.   
198.     
199.   
200. Looper   
201.   
202. Looper扮演着一个Handler和消息队列之间通讯桥梁的角色。程序组件首先通过Handler把消息传递给Looper，Looper把消息放入队列。Looper也把消息队列里的消息广播给所有的Handler，Handler接受到消息后调用handleMessage进行处理。   
203.   
204. 1)   可以通过Looper类的静态方法Looper.myLooper得到当前线程的Looper实例，如果当前线程未关联一个Looper实例，该方法将返回空。   
205.   
206. 2)   可以通过静态方法Looper. getMainLooper方法得到主线程的Looper实例   
207.   
208. 线程，消息队列，Handler，Looper之间的关系可以通过一个图来展示：   
209.   
210. 在了解了消息队列及其相关组件的设计思想后，我们将把天气预报的案例通过消息队列来重新实现：   
211.   
212. private EditText editText;   
213.   
214.     private Handler messageHandler;   
215.   
216.     @Override  
217.   
218.     public void onCreate(Bundle savedInstanceState) {   
219.   
220.         super.onCreate(savedInstanceState);   
221.   
222.         setContentView(R.layout.main);   
223.   
224.         editText = (EditText) findViewById(R.id.weather_city_edit);   
225.   
226.         Button button = (Button) findViewById(R.id.goQuery);   
227.   
228.         button.setOnClickListener(this);   
229.   
230.         //得到当前线程的Looper实例，由于当前线程是UI线程也可以通过Looper.getMainLooper()得到   
231.   
232.         Looper looper = Looper.myLooper();   
233.   
234.         //此处甚至可以不需要设置Looper，因为 Handler默认就使用当前线程的Looper   
235.   
236.         messageHandler = new MessageHandler(looper);   
237.   
238.     }   
239.   
240.     
241.   
242.     @Override  
243.   
244.     public void onClick(View v) {   
245.   
246.         //创建一个子线程去做耗时的网络连接工作   
247.   
248.         new Thread() {   
249.   
250.             @Override  
251.   
252.             public void run() {   
253.   
254.                 //活动用户输入的城市名称   
255.   
256.                 String city = editText.getText().toString();   
257.   
258.                 //调用Google 天气API查询指定城市的当日天气情况   
259.   
260.                 String weather = getWetherByCity(city);   
261.   
262.                 //创建一个Message对象，并把得到的天气信息赋值给Message对象   
263.   
264.                 Message message = Message.obtain();   
265.   
266.                 message.obj = weather;   
267.   
268.                 //通过Handler发布携带有天气情况的消息   
269.   
270.                 messageHandler.sendMessage(message);   
271.   
272.             }   
273.   
274.         }.start();   
275.   
276.     }   
277.   
278.     
279.   
280.     //子类化一个Handler   
281.   
282.     class MessageHandler extends Handler {   
283.   
284.         public MessageHandler(Looper looper) {   
285.   
286.             super(looper);   
287.   
288.         }   
289.   
290.         @Override  
291.   
292.         public void handleMessage(Message msg) {   
293.   
294.             //处理收到的消息，把天气信息显示在title上   
295.   
296.             setTitle((String) msg.obj);   
297.   
298.         }   
299.   
300.     }   
301.   
302. 通过消息队列改写过后的天气预报程序已经可以成功运行，因为Handler的handleMessage方法实际是由关联有该消息队列的UI thread调用，而在UI thread中更新title并没有违背Android的单线程模型的原则。   
303.   
304. 2.3 AsyncTask   
305.   
306. 虽然借助消息队列已经可以较为完美的实现了天气预报的功能，但是你还是不得不自己管理子线程，尤其当你的需要有一些复杂的逻辑以及需要频繁的更新UI的时候，这样的方式使得你的代码难以阅读和理解。   
307.   
308. 幸运的是Android另外提供了一个工具类：AsyncTask。它使得UI thread的使用变得异常简单。它使创建需要与用户界面交互的长时间运行的任务变得更简单，不需要借助线程和Handler即可实现。   
309.   
310. 1)   子类化AsyncTask   
311.   
312. 2)   实现AsyncTask中定义的下面一个或几个方法   
313.   
314. ?  onPreExecute(), 该方法将在执行实际的后台操作前被UI thread调用。可以在该方法中做一些准备工作，如在界面上显示一个进度条。   
315.   
316. ?  doInBackground(Params...), 将在onPreExecute 方法执行后马上执行，该方法运行在后台线程中。这里将主要负责执行那些很耗时的后台计算工作。可以调用publishProgress方法来更新实时的任务进度。该方法是抽象方法，子类必须实现。   
317.   
318. ?  3. onProgressUpdate(Progress...),在publishProgress方法被调用后，UI thread将调用这个方法从而在界面上展示任务的进展情况，例如通过一个进度条进行展示。   
319.   
320. ?  4. onPostExecute(Result), 在doInBackground 执行完成后，onPostExecute 方法将被UI thread调用，后台的计算结果将通过该方法传递到UI thread.   
321.   
322. 为了正确的使用AsyncTask类，以下是几条必须遵守的准则：   
323.   
324. 1)   Task的实例必须在UI thread中创建   
325.   
326. 2)   execute方法必须在UI thread中调用   
327.   
328. 3)   不要手动的调用onPreExecute(), onPostExecute(Result)，doInBackground(Params...), onProgressUpdate(Progress...)这几个方法   
329.   
330. 4)   该task只能被执行一次，否则多次调用时将会出现异常   
331.   
332. 下面我们将通过AsyncTask并且严格遵守上面的4条准则来改写天气预报的例子：   
333.   
334.     public void onCreate(Bundle savedInstanceState) {   
335.   
336.        super.onCreate(savedInstanceState);   
337.   
338.        setContentView(R.layout.main);   
339.   
340.        editText = (EditText) findViewById(R.id.weather_city_edit);   
341.   
342.        Button button = (Button) findViewById(R.id.goQuery);   
343.   
344.        button.setOnClickListener(this);   
345.   
346.     }   
347.   
348.     public void onClick(View v) {   
349.   
350.        //获得用户输入的城市名称   
351.   
352.        String city = editText.getText().toString();   
353.   
354.     //必须每次都重新创建一个新的task实例进行查询，否则将提示如下异常信息   
355.   
356.     //the task has already been executed (a task can be executed only once)   
357.   
358.        new GetWeatherTask().execute(city);   
359.   
360.     }   
361.   
362.     class GetWeatherTask extends AsyncTask<String, Integer, String> {   
363.   
364.        @Override  
365.   
366.        protected String doInBackground(String... params) {   
367.   
368.            String city = params[0];   
369.   
370.            //调用Google 天气API查询指定城市的当日天气情况   
371.   
372.            return getWetherByCity(city);   
373.   
374.        }   
375.   
376.        protected void onPostExecute(String result) {   
377.   
378.            //把doInBackground处理的结果即天气信息显示在title上   
379.   
380.            setTitle(result);   
381.   
382.        }   
383.   
384.     }   
385.   
386. 注意这行代码：new GetWeatherTask().execute(city); 值得一提的是必须每次都重新创建一个新的GetWeatherTask来执行后台任务，否则Android会提示“a task can be executed only once”的错误信息。   
387.   
388. 经过改写后的程序不仅显得非常的简洁，而且还减少了代码量，大大增强了可读性和可维护性。因为负责更新UI的onPostExecute方法是由UI thread调用，所以没有违背单线程模型的原则。良好的AsyncTask设计大大降低了我们犯错误的几率。   
389.   
390.     
391.   
392. 5综述   
393.   
394.     本文首先大致介绍了Android的单线程模型及其原则。然后通过一个真实案例展示刚接触Android的开发人员在不理解Android的单线程模型下容易犯的错误。最后通过几种正确的方式实现该案例，进一步认识和理解Android的单线程模型及其原则。由于更多地关注线程模型，本文或许不足以帮助读者全面的认识Android技术，关于文中提到的其他技术细节以及Android的其他相关技术可以访问Android的官方网站进行进一步的了解和学习