Android深入浅出学习笔记之多线程及异步处理

 

 一、目前线程用两种方法实现：
    （1）用户态线程：（Linux）
    由于内核并没有对多线程进程的支持，因此，内核中只有单线程进程的概念， 而多线程进程是通过一个和应用程序连接的函数库实现的。由于内核没有轻量 级进程（线程）的概念，因此它不能独立的对之进行调度，而是由一个线程运 行库来组织线程的调度，其主要工作在于在各个线程的栈之间调度。如果一个进程中的某一个线程调用了一个阻塞的系统调用，该进程就会被阻塞，当然该进程中的其他所有线程也同时被阻塞，因此UNIX使用了异步I/O机制。

    这种机制主要的缺点在于在一个进程中的多个线程的调度中无法发挥多处理器的优势（如上述的阻塞情况）。

    其优点包括：
    A （相对于进程操作而言）某些线程操作的系统消耗大大减少。比如，对属于同一个进程的线程之间进行调度切换时不需要调用系统调用，因此将减少额 外的消耗，往往一个进程可以启动上千个线程也没有什么问题。

    B 用户态线程的实现方式可以被定制或修改以适应特殊应用的要求。这对于多 媒体实时过程等尤其有用。另外，用户态线程可以比核心态线程实现方法的默认情况支持更多的线程。

LINUX的线程库有NPTL（Native POSIX Thread Library）和LinuxThreads。

    （2）核心态线程（Window）
    这种线程的实现方法允许不同进程中的线程按照同一相对优先调度方法进行调 度。这有利于发挥多处理器的并发优势。

 

 

二、Handler、Looper、MessageQueue介绍

Handler用于异步消息处理，但是Handler自己并不会创建线程。一般Handler用于计划任务和线程间的通信。

在后台线程与UI线程的交互中最常用。原理是：系统启动程序时，会自动为UI线程创建一个消息队列，和用于管理这个消息队列的Looper。在创建的后台线程时，默认是不会创建Looper和消息队列的（我们自己可以通过调用Looper.prepare()给后台线程创建Looper和消息队列）。

通过给Handler传递不同的Looper实现向不同的线程传递信息。Looper.getMainLooper()会获得UI线程的Looper。（后面我们会用代码实现）

 

三、Android多线程与界面交互的方法

1.Activity.runOnUIThread(Runnable)

 

2.View.post(Runnable)，View.postDelay(Runnable,long)

 

3、Handler

 

4、AsyncTask

 

下面用一个工程实现了上面四种交互方法

 

view plain copy to clipboard print ?

1. public class MainActivity extends Activity {  
2.   
3.     private TextView txView;  
4.     private Button button;  
5.     /** Called when the activity is first created. */  
6.     @Override  
7.     public void onCreate(Bundle savedInstanceState) {  
8.         Log.i("RootyInfo", "oncreate");  
9.         super.onCreate(savedInstanceState);  
10.         setContentView(R.layout.main);      
11.           
12.         txView=(TextView)findViewById(R.id.textView1);  
13.         button=(Button)findViewById(R.id.button1);  
14.         button.setOnClickListener(new OnClickListener() {  
15.               
16.             @Override  
17.             public void onClick(View v) {  
18.                 // TODO Auto-generated method stub  
19.                   
20.                 //创建一个用于展示前三种后台线程和UI线程交互的线程  
21.                 new TestThread(MainActivity.this).start();  
22.                   
23.                 //创建一个用于展示AsyncTask实现交互的TestAsyncTask  
24.                 new TestAsyncTask().execute("Test"," AsyncTask");  
25.             }  
26.         });  
27.     }  
28.       
29.       
30.     class TestAsyncTask extends AsyncTask<String, Integer, String>  
31.     {  
32.         //TestAsyncTask被后台线程执行后，被UI线程被调用，一般用于初始化界面控件，如进度条  
33.         @Override  
34.         protected void onPreExecute() {  
35.             // TODO Auto-generated method stub  
36.             super.onPreExecute();  
37.         }  
38.   
39.         //doInBackground执行完后由UI线程调用，用于更新界面操作  
40.         @Override  
41.         protected void onPostExecute(String result) {  
42.             // TODO Auto-generated method stub  
43.             txView.setText(result);  
44.             super.onPostExecute(result);  
45.         }  
46.   
47.         //在PreExcute执行后被启动AysncTask的后台线程调用，将结果返回给UI线程  
48.         @Override  
49.         protected String doInBackground(String... params) {  
50.             // TODO Auto-generated method stub  
51.             StringBuffer sb=new StringBuffer();  
52.             for (String string : params) {  
53.                 sb.append(string);  
54.             }  
55.             return sb.toString();  
56.         }  
57.           
58.     }  
59.     //用于线程间通信的Handler  
60.     class TestHandler extends Handler  
61.     {  
62.           
63.         public TestHandler(Looper looper) {  
64.             super(looper);  
65.             // TODO Auto-generated constructor stub  
66.         }  
67.   
68.         @Override  
69.         public void handleMessage(Message msg) {  
70.             // TODO Auto-generated method stub  
71.             System.out.println("123");  
72.             txView.setText((String)msg.getData().get("tag"));  
73.             super.handleMessage(msg);  
74.         }  
75.           
76.     }  
77.     //后台线程类  
78.     class TestThread extends Thread  
79.     {  
80.         Activity activity;  
81.         public TestThread(Activity activity) {  
82.               
83.             this.activity = activity;  
84.         }  
85.         @Override  
86.         public void run() {  
87.               
88.             //下面代码用来演示Activity.runOnUIThread(Runnable)方法的实现  
89.             activity.runOnUiThread(new Runnable() {               
90.                 @Override  
91.                 public void run() {  
92.                     // TODO Auto-generated method stub  
93.                     txView.setText("Test runOnUIThread");  
94.                 }  
95.             });  
96.               
97.             //下面代码用来演示Activity.runOnUIThread(Runnable)方法的实现  
98.             txView.post(new Runnable() {  
99.                   
100.                 @Override  
101.                 public void run() {  
102.                     // TODO Auto-generated method stub  
103.                     txView.setText("Test View.post(Runnable)");  
104.                 }  
105.             });  
106.               
107.             //下面代码用来演示Activity.runOnUIThread(Runnable)方法的实现  
108.             txView.postDelayed(new Runnable() {  
109.                   
110.                 @Override  
111.                 public void run() {  
112.                     // TODO Auto-generated method stub  
113.                     txView.setText("Test View.postDelay(Runnable,long)");  
114.                 }  
115.             }, 1000);  
116.               
117.             //下面代码用来演示Handler方法的实现  
118.             Message msg=new Message();  
119.             Bundle bundle=new Bundle();  
120.             bundle.putString("tag", "Test Handler");  
121.             msg.setData(bundle);              
122.             new TestHandler(Looper.getMainLooper()).sendMessage(msg);  
123.                       
124.             super.run();  
125.         }  
126.           
127.     }  
128.      
129. }  

 

 

出自：http://blog.csdn.net/irooty/article/details/6689410