android handler 多线程demo - shaofei的记事本 - CSDN博...

andriod提供了 Handler 和 Looper 来满足线程间的通信。为了研究其中线程机制的问题，写了2个demo：
Demo1：
view plaincopy to clipboardprint?
01.package com.mp;
02.import android.app.Activity;
03.import android.os.Bundle;
04.import android.os.Handler;
05.public class MyThread extends Activity {
06.    private Handler handler = new Handler();
07.    @Override
08.    public void onCreate(Bundle savedInstanceState) {
09.        super.onCreate(savedInstanceState);
10.        handler.post(new MyRunnable());
11.        System.out.println("Oncreate---The Thread id is :"
12.                + Thread.currentThread().getId());
13.        setContentView(R.layout.main);
14.    }
15.    private class MyRunnable implements Runnable {
16.        public void run() {
17.            System.out.println("Runnable---The Thread is running");
18.            System.out.println("Runnable---The Thread id is :"
19.                    + Thread.currentThread().getId());
20.            try {
21.                Thread.sleep(6000);
22.            } catch (InterruptedException e) {
23.                // TODO Auto-generated catch block
24.                e.printStackTrace();
25.            }
26.        }
27.    }
28.}
package com.mp;
import android.app.Activity;
import android.os.Bundle;
import android.os.Handler;
public class MyThread extends Activity {
private Handler handler = new Handler();
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
handler.post(new MyRunnable());
System.out.println("Oncreate---The Thread id is :"
+ Thread.currentThread().getId());
setContentView(R.layout.main);
}
private class MyRunnable implements Runnable {
public void run() {
System.out.println("Runnable---The Thread is running");
System.out.println("Runnable---The Thread id is :"
+ Thread.currentThread().getId());
try {
Thread.sleep(6000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
在这个demo中，整个过程如下：
程序已启动，就把MyRunnable加入到消息队列中，android的handler是异步机制，所以在handler.post(new MyRunnable());  之后，程序会继续执行，所以以后的语句会继续，这时候我们输出Oncreate中的当前线程ID。同时MyRunnable的run方法也在运行，一样输出run方法中的当前线程ID，然后让线程休眠6秒。
demo的结果分析：
1：控制台的输出： Oncreate---The Thread id is :1
Runnable---The Thread is running
Runnable---The Thread id is :1
2：程序启动后6秒，我们才看到main.xml中的内容（只有一个textview）
这2个结果都表明handler和主线程是同一个线程。如果这时候你做的是一个耗时的操作（比如下载），那么这样是不可行的。
于是，android给我们提供了Looper这样一个类。其实Android中每一个Thread都跟着一个Looper，Looper可以帮助Thread维护一个消息队列.
Demo2:
view plaincopy to clipboardprint?
01.package com.mp;
02.import android.app.Activity;
03.import android.os.Bundle;
04.import android.os.Handler;
05.import android.os.HandlerThread;
06.public class MyThread2 extends Activity {
07.    private Handler handler = null;
08.    @Override
09.    public void onCreate(Bundle savedInstanceState) {
10.        super.onCreate(savedInstanceState);
11.        HandlerThread handlerThread = new HandlerThread("myHandlerThread");
12.        handlerThread.start();
13.        handler = new Handler(handlerThread.getLooper());
14.        handler.post(new MyRunnable());
15.        System.out.println("Oncreate---The Thread id is :"
16.                + Thread.currentThread().getId());
17.        setContentView(R.layout.main);
18.    }
19.    private class MyRunnable implements Runnable {
20.        public void run() {
21.            System.out.println("Runnable---The Thread is running");
22.            System.out.println("Runnable---The Thread id is :"
23.                    + Thread.currentThread().getId());
24.            try {
25.                Thread.sleep(6000);
26.            } catch (InterruptedException e) {
27.                // TODO Auto-generated catch block
28.                e.printStackTrace();
29.            }
30.        }
31.    }
32.}
package com.mp;
import android.app.Activity;
import android.os.Bundle;
import android.os.Handler;
import android.os.HandlerThread;
public class MyThread2 extends Activity {
private Handler handler = null;
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
HandlerThread handlerThread = new HandlerThread("myHandlerThread");
handlerThread.start();
handler = new Handler(handlerThread.getLooper());
handler.post(new MyRunnable());
System.out.println("Oncreate---The Thread id is :"
+ Thread.currentThread().getId());
setContentView(R.layout.main);
}
private class MyRunnable implements Runnable {
public void run() {
System.out.println("Runnable---The Thread is running");
System.out.println("Runnable---The Thread id is :"
+ Thread.currentThread().getId());
try {
Thread.sleep(6000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
在这个demo中,用到了HandlerThread,在HandlerThread对象中可以通过getLooper方法获取一个Looper对象控制句柄，我们可以将其这个Looper对象映射到一个Handler中去来实现一个线程同步机制。于是就有以下结果;
1：控制台的输出： Oncreate---The Thread id is :1
Runnable---The Thread is running
Runnable---The Thread id is :10
2：程序启动后,我们立刻看到main.xml中的内容。
这样就达到了多线程的结果。
本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/shaofeiwang/archive/2010/10/17/5947529.aspx