android线程、UI、AsyncTask

本文是转摘的，看过了觉得很好！所以转了过来！如果你想要实现在线程中更新UI控件的话，那么这篇文章是不二之选！特别推荐文章后面介绍的AsyncTask！

Android进程 

在了解Android线程之间得先了解一下Android的进程。当一个程序第一次启动的时候，Android会启动一个LINUX进程和一个主线程。默认的情况下，所有该程序的组件都将在该进程和线程中运行。同时，Android会为每个应用程序分配一个单独的LINUX用户。Android会劲量保留一个正在运行进程，只在内存资源出现不足时，Android会参试停止一些进程从而释放足够的资源给其他新的进程使用， 也能保证用户正在访问的当前进程有足够的资源去及时的响应用户的事件。Android会 根据进程中运行的组件类别以及组件的状态来判断该进程的重要性，Android会 首先停止那些不重要的进程。按照重要性从高到低一共有五个级别： 

l  前台进程 

前台进程是用户当前正在使用的进程。只有一些前台进程可以在任何时候都存在。他们是最后一个被结束的，当内存低到根本连他们都不能运行的时候。一般来说， 在这种情况下，设备会进行内存调度，中止一些前台进程来保持对用户交互的响应。 

l  可见进程 

可见进程不包含前台的组件但是会在屏幕上显示一个可见的进程是的重要程度很高，除非前台进程需要获取它的资源，不然不会被中止。 

l  服务进程 

运行着一个通过startService() 方法启动的service，这个service不属于上面提到的2种更高重要性的。service所在的进程虽然对用户不是直接可见的，但是他们执行了用户非常关注的任务（比如播放mp3，从网络下载数据）。只要前台进程和可见进程有足够的内存，系统不会 回收他们。 

l  后台进程 

运行着一个对用户不可见的activity（调用过 onStop() 方法).这些进程对用户体验没有直接的影响，可以在服务进程、可见进程、前台进 程需要内存的时候回收。通常，系统中会有很多不可见进程在运行，他们被保存在LRU (least recently used) 列表中，以便内存不足的时候被第一时间回收。如果一个activity正 确的执行了它的生命周期，关闭这个进程对于用户体验没有太大的影响。 

l  空进程 

未运行任何程序组件。运行这些进程的唯一原因是作为一个缓存，缩短下次程序需要重新使用的启动时间。系统经常中止这些进程，这样可以调节程序缓存和系统缓 存的平衡。 

Android 对进程的重要性评级的时候，选取它最高的级别。另外，当被另外的一个进程依赖的时候，某个进程的级别可能会增高。一个为其他进程服务的进程永远不会比被服 务的进程重要级低。因为服务进程比后台activity进程重 要级高，因此一个要进行耗时工作的activity最好启动一 个service来做这个工作，而不是开启一个子进程――特别 是这个操作需要的时间比activity存在的时间还要长的时 候。例如，在后台播放音乐，向网上上传摄像头拍到的图片，使用service可 以使进程最少获取到“服务进程”级别的重要级，而不用考虑activity目 前是什么状态。broadcast receivers做费时的工作的时候，也应该启用一个服务而不是开一个线程。 

2单线程模型 

    当一个程序第一次启动时，Android会同时启动一个对应的 主线程（Main Thread），主线程主要负责处理与UI相关的事件，如：用户的按键事件，用户接触屏幕的事件以及屏幕绘图事 件，并把相关的事件分发到对应的组件进行处理。所以主线程通常又被叫做UI线 程。在开发Android应用时必须遵守单线程模型的原则： Android UI操作并不是线程安全的并且这些操作必须在UI线程中执行。 

2.1 案例演示 

如果在没有理解这样的单线程模型的情况下，设计的程序可能会使程序性能低下，因为所有的动作都在同一个线 程中触发。例如当主线程正在做一些比较耗时的操作的时候，如正从网络上下载一个大图片，或者访问数据库，由于主线程被这些耗时的操作阻塞住，无法及时的响 应用户的事件，从用户的角度看会觉得程序已经死掉。如果程序长时间不响应，用户还可能得重启系统。为了避免这样的情况，Android设 置了一个5秒 的超时时间，一旦用户的事件由于主线程阻塞而超过5秒 钟没有响应，Android会 弹出一个应用程序没有响应的对话框。下面将通过一个案例来演示这种情况： 

本程序将设计和实现查看指定城市的当天天气情况的功能， 

1.  首先，需要选择一个天气查询的 服务接口，目前可供选择的接口很多，诸如YAHOO的 天气API和Google提 供的天气API。 本文将选择GOOGLE 的 天气查询API。 该接口提供了多种查询方式，可以通过指定具体城市的经纬度进行查询，也可以通过城市名称进行查询。 

2.  用户在输入框内输入需要查询的 城市名称，然后点击查询按钮 

3.  当用户点击查询按钮后，使用已 经内置在Android SDK中的HttpClient API来调用GOOGLE 的 天气查询API， 然后解析返回的指定城市的天气信息，并把该天气信息显示在Title上 

主要代码如下：

view plain

1. public class WeatherReport extends Activity implements OnClickListener {   
2.   
3.     private static final String GOOGLE_API_URL = "http://www.google.com/ig/api?weather=";   
4.   
5.     private static final String NETWORK_ERROR = "网络异常";   
6.   
7.     private EditText editText;   
8.   
9.     @Override   
10.   
11.     public void onCreate(Bundle savedInstanceState) {   
12.   
13.         super.onCreate(savedInstanceState);   
14.   
15.         setContentView(R.layout.main);   
16.   
17.         editText = (EditText) findViewById(R.id.weather_city_edit);   
18.   
19.         Button button = (Button) findViewById(R.id.goQuery);   
20.   
21.         button.setOnClickListener(this);   
22.   
23.     }   
24.   
25.     @Override   
26.   
27.     public void onClick(View v) {   
28.   
29.         //获得用户输入的城市名称   
30.   
31.         String city = editText.getText().toString();   
32.   
33.         //调用Google 天气API查询指定城市的当日天气 情况   
34.   
35.         String weather = getWetherByCity(city);   
36.   
37.         //把天气信息显示在title上   
38.   
39.         setTitle(weather);   
40.   
41.     }   
42.   
43.       
44.   
45.     public String getWetherByCity(String city) {   
46.   
47.         HttpClient httpClient = new DefaultHttpClient();   
48.   
49.         HttpContext localContext = new BasicHttpContext();   
50.   
51.         HttpGet httpGet = new HttpGet(GOOGLE_API_URL + city);   
52.   
53.         try {   
54.   
55.             HttpResponse response = httpClient.execute(httpGet, localContext);   
56.   
57.             if (response.getStatusLine().getStatusCode() != HttpStatus.SC_OK) {   
58.   
59.                 httpGet.abort();   
60.   
61.             } else {   
62.   
63.                 HttpEntity httpEntity = response.getEntity();   
64.   
65.                 return parseWeather(httpEntity.getContent());   
66.   
67.             }   
68.   
69.         } catch (Exception e) {   
70.   
71.             Log.e("WeatherReport", "Failed to get weather", e);   
72.   
73.         } finally {   
74.   
75.             httpClient.getConnectionManager().shutdown();   
76.   
77.         }   
78.   
79.         return NETWORK_ERROR;   
80.   
81.     }   
82.   
83. }   

当用户输入城市名称，然后单击按钮进行查询后，程序会调用Google API的接口获得指定城市的当日天气情况。由于需要访问网络，所以当网络出现异常或者服务繁忙的时候都会使访问网络的动作很耗时。本文为了 要演示超时的现象，只需要制造一种网络异常的状况，最简单的方式就是断开网络连接，然后启动该程序，同时触发一个用户事件，比如按一下MENU键， 由于主线程因为网络异常而被长时间阻塞，所以用户的按键事件在5秒 钟内得不到响应，Android会 提示一个程序无法响应的异常，如下图：

该对话框会询问用户 是继续等待还是强行退出程序。当你的程序需要去访问未知的网络的时候都会可能会发生类似的超时的情况，用户的响应得不到及时的回应会大大的降低用户体验。 所以我们需要参试以别的方式来实现 


2.1 子线程更新UI 

    显然如果你的程序需要执行耗时的操作的话，如果像上例一样由主线程来负责执行 该操作是错误的。所以我们需要在onClick方 法中创建一个新的子线程来负责调用GOOGLE API来获得天气数据。刚接触Android的 开发者最容易想到的方式就是如下： 

view plain

1. public void onClick(View v) {   
2.   
3.        //创建一个子线程执行耗时的从网络上获取天气信息的操作   
4.   
5.        new Thread() {   
6.   
7.            @Override   
8.   
9.            public void run() {   
10.   
11.               //获得用户输入的城市名称   
12.   
13.               String city = editText.getText().toString();   
14.   
15.               //调用Google 天气API查询指定城市的当日天气 情况   
16.   
17.               String weather = getWetherByCity(city);   
18.   
19.               //把天气信息显示在title上   
20.   
21.               setTitle(weather);   
22.   
23.            }   
24.   
25.        }.start();   
26.   
27.     }   

但是很不幸，你会发 现Android会 提示程序由于异常而终止。为什么在其他平台上看起来很简单的代码在Android上运行的时候依然会出错呢？如果你观察LogCat中打印的日志信息就会发现这样的错误日志： 

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

从错误信息不难看出Android禁 止其他子线程来更新由UI thread创建的试图。本例中显示天气信息的title实际是就是一个由UI thread所创建的TextView，所以参试在一个子线程中去更改TextView的时候就出错了。这显示违背了单线程模型的原则：Android UI操作并不是线程安全的并且这些操作必须在UI线 程中执行 


2.2 Message Queue 

在单线程模型下，为 了解决类似的问题，Android设 计了一个Message Queue(消息队列)， 线程间可以通过该Message Queue并结合Handler和Looper组 件进行信息交换。下面将对它们进行分别介绍： 

l  Message Queue 

Message Queue是一个消息队列，用来存放通过Handler发 布的消息。消息队列通常附属于某一个创建它的线程，可以通过Looper.myQueue()得 到当前线程的消息队列。Android在 第一启动程序时会默认会为UI thread创建一个关联的消息队列，用来管理程序的一些上层组件，activities，broadcast receivers 等等。你可以在自己的子线程中创建Handler与UI thread通讯。 

l  Handler 

通过Handler你 可以发布或者处理一个消息或者是一个Runnable的 实例。没个Handler都 会与唯一的一个线程以及该线程的消息队列管理。当你创建一个新的Handler时候，默认情况下，它将关联到创建它的这个线程和该线程的消息队列。也就是说，如果你通过Handler发 布消息的话，消息将只会发送到与它关联的这个消息队列，当然也只能处理该消息队列中的消息。 

主要的方法有： 

1)   public final boolean sendMessage(Message msg) 

把消息放入该Handler所 关联的消息队列，放置在所有当前时间前未被处理的消息后。 

2)   public void handleMessage(Message msg) 

关联该消息队列的线 程将通过调用Handler的handleMessage方 法来接收和处理消息，通常需要子类化Handler来 实现handleMessage。 

l  Looper 

Looper扮演着一个Handler和 消息队列之间通讯桥梁的角色。程序组件首先通过Handler把 消息传递给Looper，Looper把 消息放入队列。Looper也 把消息队列里的消息广播给所有的Handler，Handler接 受到消息后调用handleMessage进 行处理。 

1)   可以通过Looper类 的静态方法Looper.myLooper得 到当前线程的Looper实 例，如果当前线程未关联一个Looper实 例，该方法将返回空。 

2)   可以通过静态方法Looper. getMainLooper方法得到主线程的Looper实 例 

线程，消息队列，Handler，Looper之 间的关系可以通过一个图来展示： 

在了解了消息队列及 其相关组件的设计思想后，我们将把天气预报的案例通过消息队列来重新实现： 

在了解了消息队列及其相关组件的设计思想后，我们将把天气预报的案例通过消息队列来重新实现：

view plain

1. private EditText editText;   
2.   
3.     private Handler messageHandler;   
4.   
5.     @Override   
6.   
7.     public void onCreate(Bundle savedInstanceState) {   
8.   
9.         super.onCreate(savedInstanceState);   
10.   
11.         setContentView(R.layout.main);   
12.   
13.         editText = (EditText) findViewById(R.id.weather_city_edit);   
14.   
15.         Button button = (Button) findViewById(R.id.goQuery);   
16.   
17.         button.setOnClickListener(this);   
18.   
19.         //得到当前线程 的Looper实例，由于 当前线程是UI线程也可以 通过Looper.getMainLooper()得到   
20.   
21.         Looper looper = Looper.myLooper();   
22.   
23.         //此处甚至可以 不需要设置Looper，因为 Handler默认就使用当 前线程的Looper   
24.   
25.         messageHandler = new MessageHandler(looper);   
26.   
27.     }   
28.   
29.   
30.   
31.     @Override   
32.   
33.     public void onClick(View v) {   
34.   
35.         //创建一个子线 程去做耗时的网络连接工作   
36.   
37.         new Thread() {   
38.   
39.             @Override   
40.   
41.             public void run() {   
42.   
43.                 //活动用户输入 的城市名称   
44.   
45.                 String city = editText.getText().toString();   
46.   
47.                 //调用Google 天气API查询指定城 市的当日天气情况   
48.   
49.                 String weather = getWetherByCity(city);   
50.   
51.                 //创建一个Message对象，并把得 到的天气信息赋值给Message对象   
52.   
53.                 Message message = Message.obtain();   
54.   
55.                 message.obj = weather;   
56.   
57.                 //通过Handler发布携带有天 气情况的消息   
58.   
59.                 messageHandler.sendMessage(message);   
60.   
61.             }   
62.   
63.         }.start();   
64.   
65.     }   
66.   
67.   
68.   
69.     //子类化一个Handler   
70.   
71.     class MessageHandler extends Handler {   
72.   
73.         public MessageHandler(Looper looper) {   
74.   
75.             super(looper);   
76.   
77.         }   
78.   
79.         @Override   
80.   
81.         public void handleMessage(Message msg) {   
82.   
83.             //处理收到的消 息，把天气信息显示在title上   
84.   
85.             setTitle((String) msg.obj);   
86.   
87.         }   
88.   
89.     }   

通过消息队列改写过后的天气预报程序已经可以成功运行，因为Handler的handleMessage方法实 际是由关联有该消息队列的UI thread调用，而在UI thread中更新title并没有违背Android的单线程模型的原 则。 

2.3 AsyncTask 

虽然借助消息队列已经可以较为完美的实现了天气预报的功能，但是你还是不得不自己管理子线程，尤其当你的需要有一些复杂的逻辑以及需要频繁的更新UI的时候，这样的方式使得你的代码难以阅读和理解。 

幸运的是Android另外提供了一个工具类：AsyncTask。它使得UI thread的使用变得异常简单。它使创建需要与用户界面交互的长时间运行的任务变得更简单，不需要借助线程和Handler即可实现。 

1)   子类化AsyncTask 

2)   实现AsyncTask中定义的下面一个或几个方法 

?  onPreExecute(), 该方法将在执行实际的后台操作前被UI thread调用。可以在该方法中做一些准备工作，如在界面上显示一个进度条。 

?  doInBackground(Params...), 将在onPreExecute 方法执行后马上执行，该方法运行在后台线程中。这里将主要负责执行那些很耗时的后台计算工作。可以调用publishProgress方法来更新实时的任务进度。该方法是抽象方法，子类必须实现。 

?  3. onProgressUpdate(Progress...),在publishProgress方 法被调用后，UI thread将调用这个方法从而在界面上展示任务的进展情况，例如通过一个进度条进行展示。 

?  4. 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只能被执行一次，否则多次调用时将会出现异常 

下面我们将通过AsyncTask并且严格遵守上面的4条准则来改写天气预报的例子：

 

view plain

1. public void onCreate(Bundle savedInstanceState) {   
2.   
3.        super.onCreate(savedInstanceState);   
4.   
5.        setContentView(R.layout.main);   
6.   
7.        editText = (EditText) findViewById(R.id.weather_city_edit);   
8.   
9.        Button button = (Button) findViewById(R.id.goQuery);   
10.   
11.        button.setOnClickListener(this);   
12.   
13.     }   
14.   
15.     public void onClick(View v) {   
16.   
17.        //获得用户输 入的城市名称   
18.   
19.        String city = editText.getText().toString();   
20.   
21.     //必须每次都 重新创建一个新的task实例进行 查询，否则将提示如下异常信息   
22.   
23.     //the task has already been executed (a task can be executed only once)   
24.   
25.        new GetWeatherTask().execute(city);   
26.   
27.     }   
28.   
29.     class GetWeatherTask extends AsyncTask<String, Integer, String> {   
30.   
31.        @Override   
32.   
33.        protected String doInBackground(String... params) {   
34.   
35.            String city = params[0];   
36.   
37.            //调用Google 天气API查询指定 城市的当日天气情况   
38.   
39.            return getWetherByCity(city);   
40.   
41.        }   
42.   
43.        protected void onPostExecute(String result) {   
44.   
45.            //把doInBackground处理的结果 即天气信息显示在title上   
46.   
47.            setTitle(result);   
48.   
49.        }   
50.   
51.     }   

注意这行代 码：new GetWeatherTask().execute(city); 值得一提的是必须每次都重新创建一个新的GetWeatherTask来执行后台任务，否则Android会提示“a task can be executed only once”的错误信息。 


经过改写后的 程序不仅显得非常的简洁，而且还减少了代码量，大大增强了可读性和可维护性。因为负责更新UI的onPostExecute方 法是由UI thread调用，所以没有违背单线程模型的原则。良好的AsyncTask设计大大降低了我们犯错误的几率。 

  在使用过程中，发现AsyncTask的构造函数的参数设置需要看明白：AsyncTask<Params, Progress, Result> 
    Params对应doInBackground(Params...)的参数类型。而new AsyncTask().execute(Params... params)，就是传进来的Params数据，你可以execute(data)来传送一个数据，或者execute(data1, data2, data3)这样多个数据。 
    Progress对应onProgressUpdate(Progress...)的参数类型； 
    Result对应onPostExecute(Result)的参数类型。 
    当以上的参数类型都不需要指明某个时，则使用Void，注意不是void。不明白的可以参考上面的例子，或者API Doc里面的例子。