有关Android线程的学习

1. Android进程

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

• 前台进程
  前台进程是用户当前正在使用的进程。只有一些前台进程可以在任何时候都存在。他们是最后一个被结束的，当内存低到根本连他们都不能运行的时候。一般来说， 在这种情况下，设备会进行内存调度，中止一些前台进程来保持对用户交互的响应。
• 可见进程
  可见进程不包含前台的组件但是会在屏幕上显示一个可见的进程是的重要程度很高，除非前台进程需要获取它的资源，不然不会被中止。
• 服务进程
  运行着一个通过startService() 方法启动的service，这个service不属于上面提到的2种更高重要性的。service所在的进程虽然对用户不是直接可见的，但是他们执行了用户非常关注的任务（比如播放mp3，从网络下载数据）。只要前台进程和可见进程有足够的内存，系统不会回收他们。
• 后台进程
  运行着一个对用户不可见的activity（调用过 onStop() 方法).这些进程对用户体验没有直接的影响，可以在服务进程、可见进程、前台进 程需要内存的时候回收。通常，系统中会有很多不可见进程在运行，他们被保存在LRU (least recently used) 列表中，以便内存不足的时候被第一时间回收。如果一个activity正 确的执行了它的生命周期，关闭这个进程对于用户体验没有太大的影响。
• 空进程
  未运行任何程序组件。运行这些进程的唯一原因是作为一个缓存，缩短下次程序需要重新使用的启动时间。系统经常中止这些进程，这样可以调节程序缓存和系统缓存的平衡。

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

2. 单线程模型

    当一个程序第一次启动时，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组件进行信息交换。下面将对它们进行分别介绍：

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

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

    这个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，以便回收！

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

1. public class ListProgressDemo extends ListActivity { 
2.  
3.     @Override 
4.     public void onCreate(Bundle savedInstanceState) { 
5.         super.onCreate(savedInstanceState); 
6.         setContentView(R.layout.listprogress); 
7.  
8.         ((Button) findViewById(R.id.load_Handler)).setOnClickListener(new View.OnClickListener(){ 
9.  
10.             @Override 
11.             public void onClick(View view) { 
12.                 data = null; 
13.                 data = new ArrayList<String>(); 
14.  
15.                 adapter = null; 
16.  
17.                 showDialog(PROGRESS_DIALOG); 
18.                 new ProgressThread(handler, data).start(); 
19.             } 
20.         }); 
21.     } 
22.  
23.     @Override 
24.     protected Dialog onCreateDialog(int id) { 
25.         switch(id) { 
26.         case PROGRESS_DIALOG: 
27.                  return ProgressDialog.show(this, "",  
28.                    "Loading. Please wait...", true); 
29.  
30.         default: return null; 
31.         } 
32.     } 
33.  
34.     private class ProgressThread extends Thread { 
35.  
36.         private Handler handler; 
37.         private ArrayList<String> data; 
38.  
39.         public ProgressThread(Handler handler, ArrayList<String> data) { 
40.             this.handler = handler; 
41.             this.data = data; 
42.         } 
43.  
44.         @Override 
45.         public void run() { 
46.             for (int i=0; i<8; i++) { 
47.                 data.add("ListItem"); //后台数据处理
48.                 try { 
49.                     Thread.sleep(100); 
50.                 }catch(InterruptedException e) { 
51.                      
52.                     Message msg = handler.obtainMessage(); 
53.                     Bundle b = new Bundle(); 
54.                     b.putInt("state", STATE_ERROR); 
55.                     msg.setData(b); 
56.                     handler.sendMessage(msg);  
57.                      
58.                 } 
59.             } 
60.             Message msg = handler.obtainMessage(); 
61.             Bundle b = new Bundle(); 
62.             b.putInt("state", STATE_FINISH); 
63.             msg.setData(b); 
64.             handler.sendMessage(msg); 
65.         } 
66.          
67.     } 
68.  
69.     // 此处甚至可以不需要设置Looper，因为Handler默认就使用当前线程的Looper
70.     private final Handler handler = new Handler(Looper.getMainLooper()) {
71.  
72.         public void handleMessage(Message msg) { // 处理Message，更新ListView
73.             int state = msg.getData().getInt("state"); 
74.             switch(state){ 
75.                 case STATE_FINISH: 
76.                     dismissDialog(PROGRESS_DIALOG); 
77.                     Toast.makeText(getApplicationContext(), 
78.                             "加载完成!", 
79.                             Toast.LENGTH_LONG) 
80.                          .show(); 
81.  
82.                     adapter = new ArrayAdapter<String>(getApplicationContext(), 
83.                             android.R.layout.simple_list_item_1, 
84.                             data ); 
85.                              
86.                     setListAdapter(adapter); 
87.  
88.                     break; 
89.  
90.                 case STATE_ERROR: 
91.                    dismissDialog(PROGRESS_DIALOG); 
92.                    Toast.makeText(getApplicationContext(), 
93.                            "处理过程发生错误!", 
94.                            Toast.LENGTH_LONG) 
95.                         .show(); 
96.  
97.                    adapter = new ArrayAdapter<String>(getApplicationContext(), 
98.                            android.R.layout.simple_list_item_1, 
99.                            data ); 
100.                             
101.                       setListAdapter(adapter); 
102.  
103.                       break; 
104.  
105.                default: 
106.  
107.             } 
108.         } 
109.     }; 
110.  
111.  
112.     private ArrayAdapter<String> adapter; 
113.     private ArrayList<String> data; 
114.  
115.     private static final int PROGRESS_DIALOG = 1; 
116.     private static final int STATE_FINISH = 1; 
117.     private static final int STATE_ERROR = -1; 
118. } 

这个例子，我自己写完后觉得还是有点乱，要稍微整理才能看明白线程间交互的过程以及数据的前后变化。随后了解到AsyncTask类，相应修改后就很容易明白了！

2.3 AsyncTask

1. ((Button) findViewById(R.id.load_AsyncTask)).setOnClickListener(new View.OnClickListener(){ 
2.  
3.     @Override 
4.     public void onClick(View view) { 
5.         data = null; 
6.         data = new ArrayList<String>(); 
7.  
8.         adapter = null; 
9.  
10.         //显示ProgressDialog放到AsyncTask.onPreExecute()里 
11.         //showDialog(PROGRESS_DIALOG); 
12.         new ProgressTask().execute(data); 
13.     } 
14. }); 
15.  
16. private class ProgressTask extends AsyncTask<ArrayList<String>, Void, Integer> { 
17.  
18. /* 该方法将在执行实际的后台操作前被UI thread调用。可以在该方法中做一些准备工作，如在界面上显示一个进度条。*/ 
19. @Override 
20. protected void onPreExecute() { 
21.     // 先显示ProgressDialog
22.     showDialog(PROGRESS_DIALOG); 
23. } 
24.  
25. /* 执行那些很耗时的后台计算工作。可以调用publishProgress方法来更新实时的任务进度。 */ 
26. @Override 
27. protected Integer doInBackground(ArrayList<String>... datas) { 
28.     ArrayList<String> data = datas[0]; 
29.     for (int i=0; i<8; i++) { 
30.         data.add("ListItem"); 
31.     } 
32.     return STATE_FINISH; 
33. } 
34.  
35. /* 在doInBackground 执行完成后，onPostExecute 方法将被UI thread调用， 
36.  * 后台的计算结果将通过该方法传递到UI thread. 
37.  */ 
38. @Override 
39. protected void onPostExecute(Integer result) { 
40.     int state = result.intValue(); 
41.     switch(state){ 
42.     case STATE_FINISH: 
43.         dismissDialog(PROGRESS_DIALOG); 
44.         Toast.makeText(getApplicationContext(), 
45.                 "加载完成!", 
46.                 Toast.LENGTH_LONG) 
47.              .show(); 
    
48.  
49.         adapter = new ArrayAdapter<String>(getApplicationContext(), 
50.                 android.R.layout.simple_list_item_1, 
51.                 data ); 
52.                  
53.         setListAdapter(adapter); 
    
54.  
55.         break; 
56.          
57.     case STATE_ERROR: 
58.        dismissDialog(PROGRESS_DIALOG); 
59.        Toast.makeText(getApplicationContext(), 
60.                "处理过程发生错误!", 
61.                Toast.LENGTH_LONG) 
62.             .show();
    
63.  
64.        adapter = new ArrayAdapter<String>(getApplicationContext(), 
65.                android.R.layout.simple_list_item_1, 
66.                data );
    
67.  
68.           setListAdapter(adapter);
    
69.  
70.           break;
    
71.  
72.    default:
    
73.  
74.    }
75. }

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

本文转自 Icansoft 51CTO博客，原文链接：