zoukankan      html  css  js  c++  java

  • 转：浅析Android单线程模型

    摘要：随着中国移动在8月份相继发布基于Google Android的OPhone平台和手机网上应用商店Mobile Market，以及各大手机生产厂商在2009年北京国际通信展?上展出了各自基于Android的 手机，Android技术受到越来越多的关注。基于这样的背景 下，本文将通过一个例子来初探Android的线程模型。

    关键词：Android；UI thread；线程模型
    1引言

    Android一词本义指机器人，Google于2007年11月发布了以Android命名的开源移动设备综合平台，包括其基于Linux的操作系统、中间件和关键的手机应用。并且组建了开放手机联盟，其成员囊括了全球著名的各大手机生产 商和移动运营商。2008年8月，Google又发布了网上应用商店Android Market。任何一个开发者只需要借助Android发 布的SDK开发手机应用，即可把开发的应用在Android Market上销售。目前Android Market上已经有一万多的应用程序，大大丰富了Android手机用户的功能。一个完整的产业链已经形成。因此开源Android吸引了原来越多的开发人员加入进来。本文将跟读者一起学习Android的线程模型。

    2 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上

    主要代码如下：

    [java] view plaincopyprint?
    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的 开发者最容易想到的方式就是如下：

    [java] view plaincopyprint?
    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之 间的关系可以通过一个图来展示：

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

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

    [java] view plaincopyprint?
    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条准则来改写天气预报的例子：

    [java] view plaincopyprint?
    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里面的例子。

    5综述

        本文首先大致介绍了Android的单线程模型及其原则。然后通过一个真实案例展示刚接触Android的 开发人员在不理解Android的 单线程模型下容易犯的错误。最后通过几种正确的方式实现该案例，进一步认识和理解Android的单线程模型及其原则。由于更多地关注线程模型，本文或许不足以帮助读者全面的认识Android技 术，关于文中提到的其他技术细节以及Android的 其他相关技术可以访问Android的 官方网站进行进一步的了解和学习。

    PS：另一篇相似的文章

    Android单线程模型

    单线程模型 

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


    2.1 子线程更新UI 

    Android的UI是单线程(Single-threaded)的。为了避免拖住GUI，一些较费时的对象应该交给独立的线程去执行。如果幕后的线程来执行UI对象，Android就会发出错误讯息 
    CalledFromWrongThreadException。以后遇到这样的异常抛出时就要知道怎么回事了！ 


    2.2 Message Queue 

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

    1. Message 
    Message消息，理解为线程间交流的信息，处理数据后台线程需要更新UI，则发送Message内含一些数据给UI线程。 

    2. Handler 
    Handler处理者，是Message的主要处理者，负责Message的发送，Message内容的执行处理。后台线程就是通过传进来的Handler对象引用来sendMessage(Message)。而使用Handler，需要implement 该类的 handleMessage(Message) 
    方法，它是处理这些Message的操作内容，例如Update UI。通常需要子类化Handler来实现handleMessage方法。 

    3. Message Queue 
    Message Queue消息队列，用来存放通过Handler发布的消息，按照先进先出执行。 
    每个message queue都会有一个对应的Handler。Handler会向message queue通过两种方法发送消息：sendMessage或post。这两种消息都会插在message queue队尾并按先进先出执行。但通过这两种方法发送的消息执行的方式略有不同：通过sendMessage发送的是一个message对象,会被Handler的handleMessage()函数处理；而通过post方法发送的是一个runnable对象，则会自己执行。 

    4. Looper 
    Looper是每条线程里的Message Queue的管家。Android没有Global的Message Queue，而Android会自动替主线程(UI线程)建立Message Queue，但在子线程里并没有建立Message Queue。所以调用Looper.getMainLooper()得到的主线程的Looper不为NULL，但调用Looper.myLooper()得到当前线程的Looper就有可能为NULL。 

    对于子线程使用Looper，API Doc提供了正确的使用方法： 

     1 class LooperThread extends Thread { 
 2 
 3 public Handler mHandler; 
 4 
 5 public void run() { 
 6 
 7 Looper.prepare(); //创建本线程的Looper并创建一个MessageQueue 
 8 
 9 
10 mHandler = new Handler() { 
11 
12 public void handleMessage(Message msg) { 
13 
14 // process incoming messages here 
15 
16 } 
17 
18 }; 
19 
20 Looper.loop(); //开始运行Looper,监听Message Queue 
21 
22 } 
23 
24 }


    这个Message机制的大概流程： 

    1. 在Looper.loop()方法运行开始后，循环地按照接收顺序取出Message Queue里面的非NULL的Message。 

    2. 一开始Message Queue里面的Message都是NULL的。当Handler.sendMessage(Message)到Message Queue，该函数里面设置了那个Message对象的target属性是当前的Handler对象。随后Looper取出了那个Message，则调用该Message的target指向的Hander的dispatchMessage函数对Message进行处理。 

    在dispatchMessage方法里，如何处理Message则由用户指定，三个判断，优先级从高到低： 

    1) Message里面的Callback，一个实现了Runnable接口的对象，其中run函数做处理工作； 

    2) Handler里面的mCallback指向的一个实现了Callback接口的对象，由其handleMessage进行处理； 

    3) 处理消息Handler对象对应的类继承并实现了其中handleMessage函数，通过这个实现的handleMessage函数处理消息。 

    由此可见，我们实现的handleMessage方法是优先级最低的！ 

    3. Handler处理完该Message (update UI) 后，Looper则设置该Message为NULL，以便回收！ 


    在网上有很多文章讲述主线程和其他子线程如何交互，传送信息，最终谁来执行处理信息之类的，个人理解是最简单的方法——判断Handler对象里面的Looper对象是属于哪条线程的，则由该线程来执行！ 
    1. 当Handler对象的构造函数的参数为空，则为当前所在线程的Looper； 
    2. Looper.getMainLooper()得到的是主线程的Looper对象，Looper.myLooper()得到的是当前线程的Looper对象。 

    现在来看一个例子，模拟从网络获取数据，加载到ListView的过程： 

      1 public class ListProgressDemo extends ListActivity { 
  2 
  3 @Override 
  4 
  5 public void onCreate(Bundle savedInstanceState) { 
  6 
  7 super.onCreate(savedInstanceState); 
  8 
  9 setContentView(R.layout.listprogress); 
 10 
 11 ((Button) findViewById(R.id.load_Handler)).setOnClickListener(new View.OnClickListener(){ 
 12 
 13 @Override 
 14 
 15 public void onClick(View view) { 
 16 
 17 data = null; 
 18 
 19 data = new ArrayList<String>(); 
 20 
 21 adapter = null; 
 22 
 23 showDialog(PROGRESS_DIALOG); 
 24 
 25 new ProgressThread(handler, data).start(); 
 26 
 27 } 
 28 
 29 }); 
 30 
 31 } 
 32 
 33 @Override 
 34 
 35 protected Dialog onCreateDialog(int id) { 
 36 
 37 switch(id) { 
 38 
 39 case PROGRESS_DIALOG: 
 40 
 41 return ProgressDialog.show(this, "", "Loading. Please wait...", true); 
 42 
 43 default: return null; 
 44 
 45 } 
 46 
 47 } 
 48 
 49 
 50 private class ProgressThread extends Thread { 
 51 
 52 private Handler handler; 
 53 
 54 private ArrayList<String> data; 
 55 
 56 public ProgressThread(Handler handler, ArrayList<String> data) { 
 57 
 58 this.handler = handler; 
 59 
 60 this.data = data; 
 61 
 62 } 
 63 
 64 @Override 
 65 
 66 public void run() { 
 67 
 68 for (int i=0; i<8; i++) { 
 69 
 70 data.add("ListItem"); //后台数据处理 
 71 
 72 try { 
 73 
 74 Thread.sleep(100); 
 75 
 76 }catch(InterruptedException e) { 
 77 
 78 Message msg = handler.obtainMessage(); 
 79 
 80 Bundle b = new Bundle(); 
 81 
 82 b.putInt("state", STATE_ERROR); 
 83 
 84 msg.setData(b); 
 85 
 86 handler.sendMessage(msg); 
 87 
 88 } 
 89 
 90 } 
 91 
 92 Message msg = handler.obtainMessage(); 
 93 
 94 Bundle b = new Bundle(); 
 95 
 96 b.putInt("state", STATE_FINISH); 
 97 
 98 msg.setData(b); 
 99 
100 handler.sendMessage(msg); 
101 
102 } 
103 } 
104 
105 // 此处甚至可以不需要设置Looper，因为Handler默认就使用当前线程的Looper 
106 
107 private final Handler handler = new Handler(Looper.getMainLooper()) { 
108 
109 public void handleMessage(Message msg) { // 处理Message，更新ListView 
110 
111 int state = msg.getData().getInt("state"); 
112 
113 switch(state){ 
114 
115 case STATE_FINISH: 
116 
117 dismissDialog(PROGRESS_DIALOG); 
118 
119 Toast.makeText(getApplicationContext(), "加载完成!", Toast.LENGTH_LONG) .show(); 
120 
121 adapter = new ArrayAdapter<String>(getApplicationContext(), android.R.layout.simple_list_item_1, data ); 
122 
123 setListAdapter(adapter); 
124 
125 break; 
126 case STATE_ERROR: 
127 
128 dismissDialog(PROGRESS_DIALOG); 
129 
130 Toast.makeText(getApplicationContext(), "处理过程发生错误!", Toast.LENGTH_LONG) .show(); 
131 
132 adapter = new ArrayAdapter<String>(getApplicationContext(), android.R.layout.simple_list_item_1, data ); 
133 
134 setListAdapter(adapter); 
135 break; 
136 default: 
137 } 
138 
139 } 
140 
141 }; 
142 
143 private ArrayAdapter<String> adapter; 
144 
145 private ArrayList<String> data; 
146 
147 private static final int PROGRESS_DIALOG = 1; 
148 
149 private static final int STATE_FINISH = 1; 
150 
151 private static final int STATE_ERROR = -1; 
152 
153 } 
154 
155 这个例子，我自己写完后觉得还是有点乱，要稍微整理才能看明白线程间交互的过程以及数据的前后变化。随后了解到AsyncTask类，相应修改后就很容易明白了！ 
156 
157 
158 2.3 AsyncTask 
159 AsyncTask版： 
160 
161 ((Button) findViewById(R.id.load_AsyncTask)).setOnClickListener(new View.OnClickListener(){ 
162 
163 @Override 
164 
165 public void onClick(View view) { 
166 
167 data = null; 
168 
169 data = new ArrayList<String>(); 
170 
171 adapter = null; 
172 
173 //显示ProgressDialog放到AsyncTask.onPreExecute()里 
174 
175 //showDialog(PROGRESS_DIALOG); 
176 
177 new ProgressTask().execute(data); 
178 
179 } 
180 
181 }); 
182 
183 private class ProgressTask extends AsyncTask<ArrayList<String>, Void, Integer> { 
184 
185 /* 该方法将在执行实际的后台操作前被UI thread调用。可以在该方法中做一些准备工作，如在界面上显示一个进度条。*/ 
186 
187 @Override 
188 
189 protected void onPreExecute() { 
190 
191 // 先显示ProgressDialog 
192 
193 showDialog(PROGRESS_DIALOG); 
194 
195 } 
196 
197 /* 执行那些很耗时的后台计算工作。可以调用publishProgress方法来更新实时的任务进度。 */ 
198 
199 @Override 
200 
201 protected Integer doInBackground(ArrayList<String>... datas) { 
202 
203 ArrayList<String> data = datas[0]; 
204 
205 for (int i=0; i<8; i++) { 
206 
207 data.add("ListItem"); 
208 
209 } 
210 
211 return STATE_FINISH; 
212 
213 } 
214 
215 /* 在doInBackground 执行完成后，onPostExecute 方法将被UI thread调用， 
216 
217 * 后台的计算结果将通过该方法传递到UI thread. 
218 
219 */ 
220 
221 @Override 
222 
223 protected void onPostExecute(Integer result) { 
224 
225 int state = result.intValue(); 
226 
227 switch(state){ 
228 
229 case STATE_FINISH: 
230 
231 dismissDialog(PROGRESS_DIALOG); 
232 
233 Toast.makeText(getApplicationContext(), "加载完成!", Toast.LENGTH_LONG) .show(); 
234 
235 adapter = new ArrayAdapter<String>(getApplicationContext(), android.R.layout.simple_list_item_1, data ); 
236 setListAdapter(adapter); 
237 break; 
238 case STATE_ERROR: 
239 dismissDialog(PROGRESS_DIALOG); 
240 Toast.makeText(getApplicationContext(), "处理过程发生错误!", Toast.LENGTH_LONG) .show(); 
241 
242 adapter = new ArrayAdapter<String>(getApplicationContext(), android.R.layout.simple_list_item_1, data ); 
243 setListAdapter(adapter); 
244 break; 
245 default: 
246 } 
247 }
  • 相关阅读:
    [Leetcode] Maximum Gap
    [Leetcode] Reverse Integer
    [Leetcode] Pow(x, n)
    Theano2.1.21-基础知识之theano中多核的支持
    Theano2.1.3-基础知识之更多的例子
    Theano2.1.17-基础知识之剖析theano的函数
    Theano2.1.16-基础知识之调试：常见的问题解答
    Theano2.1.15-基础知识之theano如何处理shapre信息
    Theano2.1.14-基础知识之理解为了速度和正确性的内存别名
    Theano2.1.13-基础知识之PyCUDA、CUDAMat、Gnumpy的兼容
  • 原文地址：https://www.cnblogs.com/qingblog/p/2606219.html
Copyright © 2011-2022 走看看