观点一：

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

观点二：

在开发Android应用时必须遵守单线程模型的原则： Android UI操作并不是线程安全的，并且这些操作必须在UI线程中执行。

观点三：

为了避免拖住GUI，一些较费时的对象应该交给独立的线程去执行。如果幕后的线程来执行UI对象，Android就会发出错误讯息 CalledFromWrongThreadException。

观点四：Handler

  handler可以分发Message对象和Runnable对象到主线程中。

每个Handler实例,都会绑定到创建他的线程中(一般是位于主线程),
        它有两个作用: (1):  安排消息或Runnable 在某个主线程中某个地方执行, (2)安排一个动作在不同的线程中执行

观点五： Message Queue

观点六： Looper是每条线程里的Message Queue的管家。

主要转自http://android.blog.51cto.com/268543/343823/

一个异步加载listview的例子，用2种方法：

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

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

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

2.3 AsyncTask

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

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