1.通常的使用方法
//handler
case R.id.handler:
printThreadinfo(Thread.currentThread(),"sendMessage");
mHandler.sendEmptyMessage(10);
Logger.i("handler", "===next_start==");
int i=1;
Toast.makeText(this, "test!!", i).show();
Logger.i("handler", "===next_end==");
break;
private void printThreadinfo(Thread mthread,String tag) {
Logger.i("handler", "=====tag_start====="+tag);
Logger.i("handler", "current_thread_id:"+mthread.getId());
Logger.i("handler", "current_thread_name:"+mthread.getName());
Logger.i("handler", "current_thread_Priority:"+mthread.getPriority());
Logger.i("handler", "=====tag_end====="+tag);
}
//创建一个handler对象
private Handler mHandler = new Handler(){
public void handleMessage(android.os.Message msg) {
switch (msg.what) {
case 10:
printThreadinfo(Thread.currentThread(),"receiveMessage");
break;
default:
break;
}
};
};
Log打印:
I/handler (14726): =====tag_start=====sendMessage
I/handler (14726): current_thread_id:1
I/handler (14726): current_thread_name:main
I/handler (14726): current_thread_Priority:5
I/handler (14726): =====tag_end=====sendMessage
I/handler (14726): ===next_start==
I/handler (14726): ===next_end==
I/handler (14726): =====tag_start=====receiveMessage
I/handler (14726): current_thread_id:1
I/handler (14726): current_thread_name:main
I/handler (14726): current_thread_Priority:5
I/handler (14726): =====tag_end=====receiveMessage
总结:可以看到,发送和接收都是在main线程里处理的。
2.handler looper MessageQueue Thread 关系
2.1在主线程中使用handler并没有看到looper的身影,那是因为主线程已经创建了looper对象,并且该looper对象和主线程
绑定到一块了,looper内部建立了消息循环机制,然后从消息队列MessageQueue中取出消息Message,然后让发出该Message
的handler来处理,handler和looper建立的关系是从looper和Thread的绑定后,handler从Thread那获取的looper对象。
2.2 如果在一个新的线程中new一个handler对象,就要有looper和新线程的绑定了
class MyThread extends Thread {
public void run() {
Log.d(Constant.TAG, MessageFormat.format("Thread[{0}]-- run...", Thread
.currentThread().getName()));
// 其它线程中新建一个handler
Looper.prepare();// 创建该线程的Looper对象,用于接收消息,在非主线程中是没有looper的所以在创建handler前一定要使用prepare()创建一个Looper
myThreadHandler = new Handler() {
public void handleMessage(android.os.Message msg) {
Log.d(Constant.TAG, MessageFormat.format("Thread[{0}]--myThreadHandler handleMessage run...", Thread
.currentThread().getName()));
}
};
Looper.myLooper().loop();//建立一个消息循环,该线程不会退出
}
}
3.其实2.2中的写法暂时没有发现有什么卵用啊,使用handler的目的是什么呢,不就是为了异步处理吗,那正常的逻辑应该
主线程里new个handler,然后耗时的操作开一个子线程,等耗时操作在子线程里执行完了,那就通过使用handler发个消息
给主线程,这个时候在handlermessage方法中去更新UI
class MyThread extends Thread {
public void run() {
Log.i("handler", "==taste_time==");
printThreadinfo(Thread.currentThread(),"sendMessage11");
mHandler.sendEmptyMessage(11);
}
}
//创建一个handler对象
private Handler mHandler = new Handler(){
public void handleMessage(android.os.Message msg) {
switch (msg.what) {
case 10:
printThreadinfo(Thread.currentThread(),"receiveMessage");
break;
case 11:
printThreadinfo(Thread.currentThread(),"receiveMessage11");
break;
default:
break;
}
};
};
触发:这里应该考虑New了很多线程的问题
new MyThread().start();
3.还有一种使用HanderThread来开子线程的方式
参考:http://blog.sina.com.cn/s/blog_77c6324101016jp8.html
//打印了当前线程的ID
System.out.println("Activity-->" + Thread.currentThread().getId());
//生成一个HandlerThread对象
HandlerThread handlerThread = new HandlerThread("handler_thread");
//在使用HandlerThread的getLooper()方法之前,必须先调用该类的start(),同时开启一个新线程;
handlerThread.start();
//将由HandlerThread获取的Looper传递给Handler对象,即由处于另外线程的Looper代替handler初始化时默认绑定的消息队列来处理消息。
// HandlerThread顾名思义就是可以处理消息循环的线程,它是一个拥有Looper的线程
// ,可以处理消息循环; 其实与其说Handler和一个线程绑定,倒不如说Handler和Looper是
// 一一对应的。
MyHandler myHandler = new MyHandler(handlerThread.getLooper());
Message msg = myHandler.obtainMessage();
//将msg发送到目标对象,所谓的目标对象,就是生成该msg对象的handler对象
Bundle b = new Bundle();
b.putInt("age", 20);
b.putString("name", "Jhon");
msg.setData(b);
msg.sendToTarget(); //将msg发送到myHandler
//定义类
class MyHandler extends Handler{
public MyHandler(){
}
public MyHandler(Looper looper){
super(looper);
}
@Override
public void handleMessage(Message msg) {
Bundle b = msg.getData();
int age = b.getInt("age");
String name = b.getString("name");
System.out.println("age is " + age + ", name is" + name);
System.out.println("Handler--->" + Thread.currentThread().getId());
System.out.println("handlerMessage");
}
}
log输出:
I/System.out( 2395): Activity-->1
I/System.out( 2395): age is 20, name isJhon
I/System.out( 2395): Handler--->2983
I/System.out( 2395): handlerMessage
总结:这种方式是把handler和子线程(HandlerThread开的)中的Looper绑定的,那handleMessage方法是在子线程
中执行的,这种模式使用就是主线程需要把耗时的操作给子线程做,这种模式估计也没有什么卵用。
4.线程之间的消息如何进行传递的
参考:http://blog.csdn.net/yhb5566/article/details/7342786
1、主线程给自己发送Message
package test.message;
import android.app.Activity;
import android.os.Bundle;
import android.os.Handler;
import android.os.Looper;
import android.os.Message;
import android.view.View;
import android.widget.Button;
import android.widget.TextView;
public class MainActivity extends Activity {
private Button btnTest;
private TextView textView;
private Handler handler;
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
btnTest = (Button)this.findViewById(R.id.btn_01);
textView = (TextView)this.findViewById(R.id.view_01);
btnTest.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View arg0) {
Looper looper = Looper.getMainLooper(); //主线程的Looper对象
//这里以主线程的Looper对象创建了handler,
//所以,这个handler发送的Message会被传递给主线程的MessageQueue。
handler = new MyHandler(looper);
handler.removeMessages(0);
//构建Message对象
//第一个参数:是自己指定的message代号,方便在handler选择性地接收
//第二三个参数没有什么意义
//第四个参数需要封装的对象
Message msg = handler.obtainMessage(1,1,1,"主线程发消息了");
handler.sendMessage(msg); //发送消息
}
});
}
class MyHandler extends Handler{
public MyHandler(Looper looper){
super(looper);
}
public void handleMessage(Message msg){
super.handleMessage(msg);
textView.setText("我是主线程的Handler,收到了消息:"+(String)msg.obj);
}
}
}
2、其他线程给主线程发送Message
package test.message;
import android.app.Activity;
import android.os.Bundle;
import android.os.Handler;
import android.os.Looper;
import android.os.Message;
import android.view.View;
import android.widget.Button;
import android.widget.TextView;
public class MainActivity extends Activity {
private Button btnTest;
private TextView textView;
private Handler handler;
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
btnTest = (Button)this.findViewById(R.id.btn_01);
textView = (TextView)this.findViewById(R.id.view_01);
btnTest.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View arg0) {
//可以看出这里启动了一个线程来操作消息的封装和发送的工作
//这样原来主线程的发送就变成了其他线程的发送,简单吧?呵呵
new MyThread().start();
}
});
}
class MyHandler extends Handler{
public MyHandler(Looper looper){
super(looper);
}
public void handleMessage(Message msg){
super.handleMessage(msg);
textView.setText("我是主线程的Handler,收到了消息:"+(String)msg.obj);
}
}
//加了一个线程类
class MyThread extends Thread{
public void run(){
Looper looper = Looper.getMainLooper(); //主线程的Looper对象
//这里以主线程的Looper对象创建了handler,
//所以,这个handler发送的Message会被传递给主线程的MessageQueue。
handler = new MyHandler(looper);
//构建Message对象
//第一个参数:是自己指定的message代号,方便在handler选择性地接收
//第二三个参数没有什么意义
//第四个参数需要封装的对象
Message msg = handler.obtainMessage(1,1,1,"其他线程发消息了");
handler.sendMessage(msg); //发送消息
}
}
}
3、主线程给其他线程发送Message
package test.message;
import android.app.Activity;
import android.os.Bundle;
import android.os.Handler;
import android.os.Looper;
import android.os.Message;
import android.view.View;
import android.widget.Button;
import android.widget.TextView;
public class MainActivity extends Activity {
private Button btnTest;
private TextView textView;
private Handler handler;
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
btnTest = (Button)this.findViewById(R.id.btn_01);
textView = (TextView)this.findViewById(R.id.view_01);
//启动线程
new MyThread().start();
btnTest.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View arg0) {
//这里handler的实例化在线程中
//线程启动的时候就已经实例化了
Message msg = handler.obtainMessage(1,1,1,"主线程发送的消息");
handler.sendMessage(msg);
}
});
}
class MyHandler extends Handler{
public MyHandler(Looper looper){
super(looper);
}
public void handleMessage(Message msg){
super.handleMessage(msg);
textView.setText("我是主线程的Handler,收到了消息:"+(String)msg.obj);
}
}
class MyThread extends Thread{
public void run(){
Looper.prepare(); //创建该线程的Looper对象,用于接收消息
//注意了:这里的handler是定义在主线程中的哦,呵呵,
//前面看到直接使用了handler对象,是不是在找,在什么地方实例化的呢?
//现在看到了吧???呵呵,开始的时候实例化不了,因为该线程的Looper对象
//还不存在呢。现在可以实例化了
//这里Looper.myLooper()获得的就是该线程的Looper对象了
handler = new ThreadHandler(Looper.myLooper());
//这个方法,有疑惑吗?
//其实就是一个循环,循环从MessageQueue中取消息。
//不经常去看看,你怎么知道你有新消息呢???
Looper.loop();
}
//定义线程类中的消息处理类
class ThreadHandler extends Handler{
public ThreadHandler(Looper looper){
super(looper);
}
public void handleMessage(Message msg){
//这里对该线程中的MessageQueue中的Message进行处理
//这里我们再返回给主线程一个消息
handler = new MyHandler(Looper.getMainLooper());
Message msg2 = handler.obtainMessage(1,1,1,"子线程收到:"+(String)msg.obj);
handler.sendMessage(msg2);
}
}
}
}
4、其他线程给自己发送Message
package test.message;
import android.app.Activity;
import android.os.Bundle;
import android.os.Handler;
import android.os.Looper;
import android.os.Message;
import android.view.View;
import android.widget.Button;
import android.widget.TextView;
public class MainActivity extends Activity {
private Button btnTest;
private TextView textView;
private Handler handler;
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
btnTest = (Button)this.findViewById(R.id.btn_01);
textView = (TextView)this.findViewById(R.id.view_01);
btnTest.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View arg0) {
//启动线程
new MyThread().start();
}
});
}
class MyHandler extends Handler{
public MyHandler(Looper looper){
super(looper);
}
public void handleMessage(Message msg){
super.handleMessage(msg);
textView.setText((String)msg.obj);
}
}
class MyThread extends Thread{
public void run(){
Looper.prepare(); //创建该线程的Looper对象
//这里Looper.myLooper()获得的就是该线程的Looper对象了
handler = new ThreadHandler(Looper.myLooper());
Message msg = handler.obtainMessage(1,1,1,"我自己");
handler.sendMessage(msg);
Looper.loop();
}
//定义线程类中的消息处理类
class ThreadHandler extends Handler{
public ThreadHandler(Looper looper){
super(looper);
}
public void handleMessage(Message msg){
//这里对该线程中的MessageQueue中的Message进行处理
//这里我们再返回给主线程一个消息
//加入判断看看是不是该线程自己发的信息
if(msg.what == 1 && msg.obj.equals("我自己")){
handler = new MyHandler(Looper.getMainLooper());
Message msg2 = handler.obtainMessage(1,1,1,"禀告主线程:我收到了自己发给自己的Message");
handler.sendMessage(msg2);
}
}
}
}
}
//handler
case R.id.handler:
printThreadinfo(Thread.currentThread(),"sendMessage");
mHandler.sendEmptyMessage(10);
Logger.i("handler", "===next_start==");
int i=1;
Toast.makeText(this, "test!!", i).show();
Logger.i("handler", "===next_end==");
break;
private void printThreadinfo(Thread mthread,String tag) {
Logger.i("handler", "=====tag_start====="+tag);
Logger.i("handler", "current_thread_id:"+mthread.getId());
Logger.i("handler", "current_thread_name:"+mthread.getName());
Logger.i("handler", "current_thread_Priority:"+mthread.getPriority());
Logger.i("handler", "=====tag_end====="+tag);
}
//创建一个handler对象
private Handler mHandler = new Handler(){
public void handleMessage(android.os.Message msg) {
switch (msg.what) {
case 10:
printThreadinfo(Thread.currentThread(),"receiveMessage");
break;
default:
break;
}
};
};
Log打印:
I/handler (14726): =====tag_start=====sendMessage
I/handler (14726): current_thread_id:1
I/handler (14726): current_thread_name:main
I/handler (14726): current_thread_Priority:5
I/handler (14726): =====tag_end=====sendMessage
I/handler (14726): ===next_start==
I/handler (14726): ===next_end==
I/handler (14726): =====tag_start=====receiveMessage
I/handler (14726): current_thread_id:1
I/handler (14726): current_thread_name:main
I/handler (14726): current_thread_Priority:5
I/handler (14726): =====tag_end=====receiveMessage
总结:可以看到,发送和接收都是在main线程里处理的。
2.handler looper MessageQueue Thread 关系
2.1在主线程中使用handler并没有看到looper的身影,那是因为主线程已经创建了looper对象,并且该looper对象和主线程
绑定到一块了,looper内部建立了消息循环机制,然后从消息队列MessageQueue中取出消息Message,然后让发出该Message
的handler来处理,handler和looper建立的关系是从looper和Thread的绑定后,handler从Thread那获取的looper对象。
2.2 如果在一个新的线程中new一个handler对象,就要有looper和新线程的绑定了
class MyThread extends Thread {
public void run() {
Log.d(Constant.TAG, MessageFormat.format("Thread[{0}]-- run...", Thread
.currentThread().getName()));
// 其它线程中新建一个handler
Looper.prepare();// 创建该线程的Looper对象,用于接收消息,在非主线程中是没有looper的所以在创建handler前一定要使用prepare()创建一个Looper
myThreadHandler = new Handler() {
public void handleMessage(android.os.Message msg) {
Log.d(Constant.TAG, MessageFormat.format("Thread[{0}]--myThreadHandler handleMessage run...", Thread
.currentThread().getName()));
}
};
Looper.myLooper().loop();//建立一个消息循环,该线程不会退出
}
}
3.其实2.2中的写法暂时没有发现有什么卵用啊,使用handler的目的是什么呢,不就是为了异步处理吗,那正常的逻辑应该
主线程里new个handler,然后耗时的操作开一个子线程,等耗时操作在子线程里执行完了,那就通过使用handler发个消息
给主线程,这个时候在handlermessage方法中去更新UI
class MyThread extends Thread {
public void run() {
Log.i("handler", "==taste_time==");
printThreadinfo(Thread.currentThread(),"sendMessage11");
mHandler.sendEmptyMessage(11);
}
}
//创建一个handler对象
private Handler mHandler = new Handler(){
public void handleMessage(android.os.Message msg) {
switch (msg.what) {
case 10:
printThreadinfo(Thread.currentThread(),"receiveMessage");
break;
case 11:
printThreadinfo(Thread.currentThread(),"receiveMessage11");
break;
default:
break;
}
};
};
触发:这里应该考虑New了很多线程的问题
new MyThread().start();
3.还有一种使用HanderThread来开子线程的方式
参考:http://blog.sina.com.cn/s/blog_77c6324101016jp8.html
//打印了当前线程的ID
System.out.println("Activity-->" + Thread.currentThread().getId());
//生成一个HandlerThread对象
HandlerThread handlerThread = new HandlerThread("handler_thread");
//在使用HandlerThread的getLooper()方法之前,必须先调用该类的start(),同时开启一个新线程;
handlerThread.start();
//将由HandlerThread获取的Looper传递给Handler对象,即由处于另外线程的Looper代替handler初始化时默认绑定的消息队列来处理消息。
// HandlerThread顾名思义就是可以处理消息循环的线程,它是一个拥有Looper的线程
// ,可以处理消息循环; 其实与其说Handler和一个线程绑定,倒不如说Handler和Looper是
// 一一对应的。
MyHandler myHandler = new MyHandler(handlerThread.getLooper());
Message msg = myHandler.obtainMessage();
//将msg发送到目标对象,所谓的目标对象,就是生成该msg对象的handler对象
Bundle b = new Bundle();
b.putInt("age", 20);
b.putString("name", "Jhon");
msg.setData(b);
msg.sendToTarget(); //将msg发送到myHandler
//定义类
class MyHandler extends Handler{
public MyHandler(){
}
public MyHandler(Looper looper){
super(looper);
}
@Override
public void handleMessage(Message msg) {
Bundle b = msg.getData();
int age = b.getInt("age");
String name = b.getString("name");
System.out.println("age is " + age + ", name is" + name);
System.out.println("Handler--->" + Thread.currentThread().getId());
System.out.println("handlerMessage");
}
}
log输出:
I/System.out( 2395): Activity-->1
I/System.out( 2395): age is 20, name isJhon
I/System.out( 2395): Handler--->2983
I/System.out( 2395): handlerMessage
总结:这种方式是把handler和子线程(HandlerThread开的)中的Looper绑定的,那handleMessage方法是在子线程
中执行的,这种模式使用就是主线程需要把耗时的操作给子线程做,这种模式估计也没有什么卵用。
4.线程之间的消息如何进行传递的
参考:http://blog.csdn.net/yhb5566/article/details/7342786
1、主线程给自己发送Message
package test.message;
import android.app.Activity;
import android.os.Bundle;
import android.os.Handler;
import android.os.Looper;
import android.os.Message;
import android.view.View;
import android.widget.Button;
import android.widget.TextView;
public class MainActivity extends Activity {
private Button btnTest;
private TextView textView;
private Handler handler;
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
btnTest = (Button)this.findViewById(R.id.btn_01);
textView = (TextView)this.findViewById(R.id.view_01);
btnTest.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View arg0) {
Looper looper = Looper.getMainLooper(); //主线程的Looper对象
//这里以主线程的Looper对象创建了handler,
//所以,这个handler发送的Message会被传递给主线程的MessageQueue。
handler = new MyHandler(looper);
handler.removeMessages(0);
//构建Message对象
//第一个参数:是自己指定的message代号,方便在handler选择性地接收
//第二三个参数没有什么意义
//第四个参数需要封装的对象
Message msg = handler.obtainMessage(1,1,1,"主线程发消息了");
handler.sendMessage(msg); //发送消息
}
});
}
class MyHandler extends Handler{
public MyHandler(Looper looper){
super(looper);
}
public void handleMessage(Message msg){
super.handleMessage(msg);
textView.setText("我是主线程的Handler,收到了消息:"+(String)msg.obj);
}
}
}
2、其他线程给主线程发送Message
package test.message;
import android.app.Activity;
import android.os.Bundle;
import android.os.Handler;
import android.os.Looper;
import android.os.Message;
import android.view.View;
import android.widget.Button;
import android.widget.TextView;
public class MainActivity extends Activity {
private Button btnTest;
private TextView textView;
private Handler handler;
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
btnTest = (Button)this.findViewById(R.id.btn_01);
textView = (TextView)this.findViewById(R.id.view_01);
btnTest.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View arg0) {
//可以看出这里启动了一个线程来操作消息的封装和发送的工作
//这样原来主线程的发送就变成了其他线程的发送,简单吧?呵呵
new MyThread().start();
}
});
}
class MyHandler extends Handler{
public MyHandler(Looper looper){
super(looper);
}
public void handleMessage(Message msg){
super.handleMessage(msg);
textView.setText("我是主线程的Handler,收到了消息:"+(String)msg.obj);
}
}
//加了一个线程类
class MyThread extends Thread{
public void run(){
Looper looper = Looper.getMainLooper(); //主线程的Looper对象
//这里以主线程的Looper对象创建了handler,
//所以,这个handler发送的Message会被传递给主线程的MessageQueue。
handler = new MyHandler(looper);
//构建Message对象
//第一个参数:是自己指定的message代号,方便在handler选择性地接收
//第二三个参数没有什么意义
//第四个参数需要封装的对象
Message msg = handler.obtainMessage(1,1,1,"其他线程发消息了");
handler.sendMessage(msg); //发送消息
}
}
}
3、主线程给其他线程发送Message
package test.message;
import android.app.Activity;
import android.os.Bundle;
import android.os.Handler;
import android.os.Looper;
import android.os.Message;
import android.view.View;
import android.widget.Button;
import android.widget.TextView;
public class MainActivity extends Activity {
private Button btnTest;
private TextView textView;
private Handler handler;
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
btnTest = (Button)this.findViewById(R.id.btn_01);
textView = (TextView)this.findViewById(R.id.view_01);
//启动线程
new MyThread().start();
btnTest.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View arg0) {
//这里handler的实例化在线程中
//线程启动的时候就已经实例化了
Message msg = handler.obtainMessage(1,1,1,"主线程发送的消息");
handler.sendMessage(msg);
}
});
}
class MyHandler extends Handler{
public MyHandler(Looper looper){
super(looper);
}
public void handleMessage(Message msg){
super.handleMessage(msg);
textView.setText("我是主线程的Handler,收到了消息:"+(String)msg.obj);
}
}
class MyThread extends Thread{
public void run(){
Looper.prepare(); //创建该线程的Looper对象,用于接收消息
//注意了:这里的handler是定义在主线程中的哦,呵呵,
//前面看到直接使用了handler对象,是不是在找,在什么地方实例化的呢?
//现在看到了吧???呵呵,开始的时候实例化不了,因为该线程的Looper对象
//还不存在呢。现在可以实例化了
//这里Looper.myLooper()获得的就是该线程的Looper对象了
handler = new ThreadHandler(Looper.myLooper());
//这个方法,有疑惑吗?
//其实就是一个循环,循环从MessageQueue中取消息。
//不经常去看看,你怎么知道你有新消息呢???
Looper.loop();
}
//定义线程类中的消息处理类
class ThreadHandler extends Handler{
public ThreadHandler(Looper looper){
super(looper);
}
public void handleMessage(Message msg){
//这里对该线程中的MessageQueue中的Message进行处理
//这里我们再返回给主线程一个消息
handler = new MyHandler(Looper.getMainLooper());
Message msg2 = handler.obtainMessage(1,1,1,"子线程收到:"+(String)msg.obj);
handler.sendMessage(msg2);
}
}
}
}
4、其他线程给自己发送Message
package test.message;
import android.app.Activity;
import android.os.Bundle;
import android.os.Handler;
import android.os.Looper;
import android.os.Message;
import android.view.View;
import android.widget.Button;
import android.widget.TextView;
public class MainActivity extends Activity {
private Button btnTest;
private TextView textView;
private Handler handler;
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
btnTest = (Button)this.findViewById(R.id.btn_01);
textView = (TextView)this.findViewById(R.id.view_01);
btnTest.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View arg0) {
//启动线程
new MyThread().start();
}
});
}
class MyHandler extends Handler{
public MyHandler(Looper looper){
super(looper);
}
public void handleMessage(Message msg){
super.handleMessage(msg);
textView.setText((String)msg.obj);
}
}
class MyThread extends Thread{
public void run(){
Looper.prepare(); //创建该线程的Looper对象
//这里Looper.myLooper()获得的就是该线程的Looper对象了
handler = new ThreadHandler(Looper.myLooper());
Message msg = handler.obtainMessage(1,1,1,"我自己");
handler.sendMessage(msg);
Looper.loop();
}
//定义线程类中的消息处理类
class ThreadHandler extends Handler{
public ThreadHandler(Looper looper){
super(looper);
}
public void handleMessage(Message msg){
//这里对该线程中的MessageQueue中的Message进行处理
//这里我们再返回给主线程一个消息
//加入判断看看是不是该线程自己发的信息
if(msg.what == 1 && msg.obj.equals("我自己")){
handler = new MyHandler(Looper.getMainLooper());
Message msg2 = handler.obtainMessage(1,1,1,"禀告主线程:我收到了自己发给自己的Message");
handler.sendMessage(msg2);
}
}
}
}
}
总结:就是主线程和子线程之间或自身间的消息发送,对应自身间的传递也没有什么卵用。
其实android中有封装好的handler+thread的工具,那就是AsyncTask