多线程编程 Handler、MessageQueue、Looper

最新推荐文章于 2024-07-03 09:07:31 发布

ymangu

最新推荐文章于 2024-07-03 09:07:31 发布

阅读量1k

点赞数

分类专栏： android

android 专栏收录该内容

202 篇文章 1 订阅

订阅专栏

1. Message
记录消息信息的类。这个类有几个比较重要的字段：
a) arg1和arg2：使用这两个字段可以用来存放我们需要传递的整型值，在Service中，我们可以用来存放Service的ID。
b) obj：该字段是Object类型，该字段可以传递某个多项到消息的接受者中。
c) what：这个字段可以说是消息的标志。类似于我们在处理Button事件时，通过switch(v.getId())判断是点击了哪个按钮。
2. MessageQueue
消息队列，用来存放Message对象的数据结构，按照“先进先出”的原则存放消息。存放并非实际意义的保存，而是将Message对象以链表的方式串联起来的。MessageQueue对象不需要我们自己创建，而是有Looper对象对其进行管理，一个线程最多只可以拥有一个MessageQueue。我们可以通过Looper.myQueue()获取当前线程中的MessageQueue。

3.Looper
Android系统中的Looper负责管理线程的消息队列和消息循环。在一个线程中，如果存在Looper对象，则必定存在MessageQueue对象，并且只存在一个Looper对象和一个MessageQueue对象。在Android系统中，除了主线程有默认的Looper对象，其它线程默认是没有Looper对象,也就没有消息队列。如果想让我们新创建的线程拥有Looper对象时，我们首先应调用Looper.prepare()方法，然后再调用Looper.loop()方法。典型的用法如下：

class WorkThread extends Thread {  
      public Handler mHandler;    
      public void run() {  
          Looper.prepare();    
          mHandler = new Handler() {  
              public void handleMessage(Message msg) {  
                  // 处理收到的消息  
              }  
          };    
          Looper.loop();  
      }  
  }

这样一来，我们创建的工作线程就具有了消息处理机制了。此外我们还可以通过Looper.getMainLooper()获取当前应用系统中主线程的Looper对象。通过源码我们可以看到loop()方法是个死循环，将会不停的从MessageQueue对象中获取Message对象，如果MessageQueue 对象中不存在Message对象，则结束本次循环，然后继续循环；如果存在Message对象，则执行 msg.target.dispatchMessage(msg)，但是这个msg的.target字段的值是什么呢？handler.sendMessage()-->handler.sendMessageDelayed()-->handler.sendMessageAtTime()-->msg.target = this;queue.enqueueMessage==>把msg添加到消息队列中。 4.Handler 消息的处理者。通过Handler对象我们可以封装Message对象，然后通过sendMessage(msg)把Message对象添加到MessageQueue中；当MessageQueue循环到该Message时，就会调用该Message对象对应的handler对象的handleMessage()方法对其进行处理。由于是在handleMessage()方法中处理消息，因此我们应该编写一个类继承自Handler，然后在handleMessage()处理我们需要的操作。构造Handler的时候可以指定一个Looper对象，如果不指定则利用当前线程的Looper对象创建。

一个Message经由Handler的发送，MessageQueue的入队，Looper的抽取，又再一次地回到Handler的怀抱中。而绕的这一圈，帮助我们将同步操作变成了异步操作。一个Activity中可以创建出多个工作线程，如果这些线程把他们消息放入Activity主线程的消息队列中，那么消息就会在主线程中处理了。因为主线程一般负责视图组件的更新操作，对于不是线程安全的视图组件来说，这种方式能够很好的实现视图的更新。

那么，子线程如何把消息放入主线程的消息队列中呢？只要Handler对象以主线程的Looper创建，那么当调用Handler的sendMessage方法，系统就会把消息主线程的消息队列，并且将会在调用handleMessage方法时处理主线程消息队列中的消息。

对于子线程访问主线程的Handler对象，你可能会问，多个子线程都访问主线程的Handler对象，发送消息和处理消息的过程中会不会出现数据的不一致呢？答案是Handler对象不会出现问题，因为Handler对象管理的Looper对象是线程安全的，不管是添加消息到消息队列还是从消息队列中读取消息都是同步保护的，所以不会出现数据不一致现象。

1. Handler和Message(一) 实例1：教科书版的写法，触发一个事件，开户一个线程，在线程的主体当中声明Message对象、赋值、发送。然后在handleMessage中处理消息。

public class MainActivity extends Activity {
private Button button;
private ImageView imageview;
private String image_path="http://d.hiphotos.baidu.com/image/pic/item/d788d43f8794a4c2a63b262f0cf41bd5ad6e399e.jpg";
private ProgressDialog dialog;
private final int is_finish=1;
private Handler handler=new Handler(){
	public void handleMessage(android.os.Message msg) {
	byte[] data=(byte[])msg.obj;
	Bitmap bm=BitmapFactory.decodeByteArray(data, 0, data.length);
	imageview.setImageBitmap(bm);
	if(msg.what==is_finish){ //接收完后对话框消失
		dialog.dismiss();		
	}	}
};
protected void onCreate(Bundle savedInstanceState) {
	super.onCreate(savedInstanceState);
	setContentView(R.layout.activity_main);
	button=(Button)this.findViewById(R.id.button1);
	imageview=(ImageView)this.findViewById(R.id.imageView1);
	dialog=new ProgressDialog(this);
	dialog.setTitle("提示信息");
	dialog.setMessage("正在下载，请稍后...");
	dialog.setCancelable(false);
	button.setOnClickListener(new View.OnClickListener() {
	public void onClick(View v) {
		new Thread(new MyThread()).start();
		dialog.show();
	}  });	
}
public class MyThread implements Runnable{
	public void run() {
	HttpClient httpClient=new DefaultHttpClient();
	HttpGet httpGet=new HttpGet(image_path);
	HttpResponse httpResponse=null;
	try {
	httpResponse=httpClient.execute(httpGet);
	if(httpResponse.getStatusLine().getStatusCode()==200){
		byte[] data=EntityUtils.toByteArray(httpResponse.getEntity());
		Message message=Message.obtain();
		message.obj=data;
		message.what=is_finish;
		handler.sendMessage(message);
	}
	} catch (Exception e) {
	}	}
}
}

在使用Message时，我们可以通过new Message()创建一个Message实例，但是Android推荐通过Message.obtain()或者Handler.obtainMessage()获取Message对象。这并不一定是直接创建一个新的实例，而是先从消息池中看有没有可用的Message实例，存在则直接取出并返回这个实例。反之如果消息池中没有可用的Message实例，则根据给定的参数new一个新Message对象。通过分析源码可得知，Android系统默认情况下在消息池中实例化10个Message对象。下面是其源码：

public static Message obtain() {
        synchronized (sPoolSync) { //同步对象
            if (sPool != null) { //判断消息池不为空
                Message m = sPool;  //从消息池中取出一个消息
                sPool = m.next;
                m.next = null;
                sPoolSize--;  //消息池大小减1
                return m;
            }
        }
        return new Message();
    }

3. Handler和Message(3)
Handler：发送并处理消息的
Message: 携带消息的，消息里包括了数据
MessageQueue：用来存储消息的
Looper：从消息队列取出消息
1.在UI的子线程中发送消息，在主线程中接收消息。
Looper 运行在消息队列的循环线程当中。默认的情况下，线程是不关联一个消息队列的。所以要在线程中调用prepare()使队列运行起来，并使用loop()方法使这个队列一直运行，直到停止。
所以Looper就是完成消息与Handler交互的一个功能，维护这个消息队列。

public class MainActivity extends Activity{  
    private MyHandler handler;
    ............
    Looper looper=Looper.myLooper();
    handler=new MyHandler(looper);
    button.setOnClickListener(new View.OnClickListener(){
    	public void onClick(View v){
    	new Thread(new MyThread()).start();
    	}
    });
}
public  class MyHandler extends Handler{
	public MyHandler(Looper looper){
		super(looper);
	}
	public void hanleMessage(Message msg){
	super.hanleMessage(msg);
	textView.setText("---接收消息-->"+msg.obj);
	}
}
public MyThread implements Runnable{
	public void run(){
		Message message=Message.obtain();
		message.obj="jacd";
		handler.sendMessage(message);
	}
}

在Activity当中有一个默认的Looper对象，来处理子线程中发送的消息。
2. 在主线程中发送消息，在子线程中接收消息

public class MainActivity extends Activity{  
    private Handler handler;
    ............
   new Thread(new MyThread()).start();
    button.setOnClickListener(new View.OnClickListener(){ 
    	public void onClick(View v){
    	Message message=Message.obtain();
    	message.obj="jacd";
    	handler.sendMessage(message);
    	}
    });
}
public MyThread implements Runnable{
	public void run(){
	Looper.prepare();//循环消息队列
	handler=new Handler(){
	public void handleMessage(Message msg){
	super.handleMessage(msg);
	System.out.println("--从UI主线程中获得消息--"+msg.obj);
	}
	};
	Looper.loop(); //直到消息队列结束 
	}
}

4、Bundle

Bundle是一数据存贮的工具，使用方法跟Map很像。它的特殊点是它的键的值是固定的string类型。Bundle中存贮的也是键值对。
5、Looper：在新线程当中处理消息，真正的异步消息处理

用handler、Runnable来启动一个线程，其它并没有启动一个独立的线程，这样有时就会出现问题，如用这种方法从网上下载文件时，一直处于等待状态，activity就会没有反应，这样是不行的。所在在实现的应用中，往往要重启一个独立的线程，怎么启动一个独立的线程呢？
这就要用到looper.可以在创建Handler对象时，为其指定Looper，就是它与哪个MessageQueue关联。

//生成一个HandlerThread对象，实现了使用Looper来处理消息队列的功能，这个类由Android应用程序框架提供  
   HandlerThread handlerThread = new HandlerThread("handler_thread");  
   //在使用HandlerThread的getLooper()方法之前，必须先调用该类的start();  
   handlerThread.start();  
   MyHandler myHandler = new MyHandler(handlerThread.getLooper());  //获得这个线程的Looper
   Message msg = myHandler.obtainMessage();  
   //将msg发送到目标对象，所谓的目标对象，就是生成该msg对象的handler对象  
   Bundle b = new Bundle();  
   b.putInt("age", 20);  
   b.putString("name", "Jhon");  
   msg.setData(b);  
   msg.sendToTarget();

MyHandler myHandler = new MyHandler(handlerThread.getLooper()); 生成一个Handler的时候，调用handlerThread的getLooper()方法，就可以得到这个线程的里所使用的looper对象了。把这个looper传递给myHandler 。然后就会调用MyHandler类的构造函数MyHandler(Looper looper)，就可以把这个myHandler 线程绑定在looper对象上面。
msg.sendToTarget(); 发送消息，跟上节课所用的通过handler来发送消息方法不一样。那这个Target是谁呢？
通过这句 Message msg = myHandler.obtainMessage(); 决定，是哪个Handler生成的msg ，就发送给哪个Handler。
msg.setData(b); 通过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());  
        }  
}

看第2个构造函数，这个MyHandler接收了一个Looper对象意味着什么呢？意味着这个Handler运用这个looper所在的线程来处理消息队列。也就是说这个Handler绑定在另外一个线程上来用消息队列中往外取数据。
里面还有个 handleMessage(Message msg): 每当我们向这个Handler发送一个msg对象时，就会调用这个Handler的handleMessage。

构造Handler对象有好几种方法，可以参考这篇文章：在Android中使用Handler和Thread线程执行后台操作