Android子线层内存,（一）Android的消息机制，用Android线程间通信的Message机制，Android中Handler的使用方法——在子线...

Android的消息机制(一)

android

有一种叫消息队列的说法，这里我们可以这样理解：假如一个隧道就是一个消息队列，那么里面的每一部汽车就是一个一个消息，这里我们先忽略掉超车等种种因素，只那么先进隧道的车将会先出，这个机制跟我们android

的消息机制是一样的。

一、

角色描述

1.Looper:(相当于隧道)

一个线程可以产生一个Looper

对象，由它来管理此线程里的Message

Queue( 车队,消息隧道)

。

2.Handler:

你可以构造Handler

对象来与Looper

沟通，以便push

新消息到Message Queue

里；或者接收Looper(

从Message Queue

取出) 所送来的消息。

3. Message Queue(

消息队列): 用来存放线程放入的消息。

4 ．线程：UI thread 通常就是main thread ，而Android 启动程序时会替它建立一个Message Queue 。

每一个线程里可含有一个Looper

对象以及一个MessageQueue

数据结构。在你的应用程序里，可以定义Handler 的子类别来接收Looper 所送出的消息。

在你的Android

程序里，新诞生一个线程，或执行 (Thread)

时，并不会自动建立其Message Loop

。

Android 里并没有Global 的Message Queue 数据结构，例如，不同APK 里的对象不能透过Massage Queue 来交换讯息(Message) 。

例如：线程A 的Handler

对象可以传递消息给别的线程，让别的线程B

或C 等能送消息来给线程A( 存于A 的Message

Queue 里) 。

线程A 的Message Queue 里的讯息，只有线程A 所属的对象可以处理。

使用Looper.myLooper

可以取得当前线程的Looper 对象。

使用mHandler = new

EevntHandler(Looper.myLooper()); 可用来构造当前线程的Handler 对象；其中，EevntHandler 是自已实现的Handler 的子类别。

使用mHandler = new

EevntHandler(Looper.getMainLooper()); 可诞生用来处理main 线程的Handler 对象；其中，EevntHandler 是自已实现的Handler 的子类别。

这样描述可能太抽像，下面举几个实际的例子来说明：

二、

举例

1.

同线程内不同组件间的消息传递

Looper

类用来管理特定线程内对象之间的消息交换(Message

Exchange)

。你的应用程序可以产生许多个线程。而一个线程可以有许多个组件，这些组件之间常常需要互相交换讯息。如果有这种需要，您可以替线程构造一个Looper 对象，来担任讯息交换的管理工作。Looper 对象会建立一个MessageQueue 数据结构来存放各对象传来的消息( 包括UI 事件或System 事件等) 。如下图：

每一个线程里可含有一个Looper

对象以及一个MessageQueue

数据结构。在你的应用程序里，可以定义Handler 的子类别来接收Looper 所送出的消息。

同线程不同组件之间的消息传递：

public class Activity1 extends Activity implements OnClickListener{

Button button = null ;

TextView text = null ;

@Override

protected

void onCreate(Bundle savedInstanceState) {

super .onCreate(savedInstanceState);

setContentView(R.layout. activity1 );

button =

(Button)findViewById(R.id. btn );

button .setOnClickListener( this );

text =

(TextView)findViewById(R.id. content );

}

public

void onClick(View v) {

switch (v.getId()) {

case R.id. btn :

Looper looper = Looper.myLooper (); // 取得当前线程里的looper

MyHandler mHandler = new MyHandler(looper); // 构造一个handler 使之可与looper 通信

//buton 等组件可以由mHandler 将消息传给looper 后, 再放入messageQueue 中, 同时mHandler 也可以接受来自looper 消息

mHandler.removeMessages(0);

String msgStr = " 主线程不同组件通信: 消息来自button" ;

Message m = mHandler.obtainMessage(1, 1, 1, msgStr);

// 构造要传递的消息

mHandler.sendMessage(m); // 发送消息: 系统会自动调用handleMessage 方法来处理消息

break ;

}

}

private

class MyHandler extends Handler{

public MyHandler(Looper looper){

super (looper);

}

@Override

public

void handleMessage(Message msg) { // 处理消息

text .setText(msg. obj .toString());

}

}

}

说明：

此程序启动时，当前线程(

即主线程, main thread)

已诞生了一个Looper

对象，并且有了一个MessageQueue

数据结构。

looper = Looper.myLooper ();

调用Looper 类别的静态myLooper() 函数，以取得目前线程里的Looper 对象.

mHandler = new MyHandler

(looper);

构造一个MyHandler 对象来与Looper 沟通。Activity 等对象可以藉由MyHandler 对象来将消息传给Looper ，然后放入MessageQueue 里；MyHandler 对象也扮演Listener 的角色，可接收Looper 对象所送来的消息。

Message m =

mHandler.obtainMessage(1, 1, 1, obj);

先构造一个Message

对象，并将数据存入对象里。

mHandler.sendMessage(m);

就透过mHandler

对象而将消息m 传给Looper ，然后放入MessageQueue 里。

此时，Looper

对象看到MessageQueue

里有消息m

，就将它广播出去，mHandler

对象接到此讯息时，会呼叫其handleMessage() 函数来处理，于是输出"This my message!" 于画面上，

Android消息处理机制(二)

角色综述(回顾):

(1)UI

thread 通常就是main

thread ，而Android

启动程序时会替它建立一个MessageQueue

。

(2) 当然需要一个Looper 对象，来管理该MessageQueue 。

(3) 我们可以构造Handler 对象来push 新消息到Message Queue 里；或者接收Looper( 从Message

Queue 取出)

所送来的消息。

(4) 线程A 的Handler 对象可以传递给别的线程，让别的线程B 或C 等能送讯息来给线程A( 存于A

的Message Queue

里) 。

(5) 线程A 的Message Queue 里的消息，只有线程A 所属的对象可以处理。

子线程传递消息给主线程

public class Activity2 extends Activity implements OnClickListener{

Button button = null ;

TextView text = null ;

MyHandler mHandler = null ;

Thread thread ;

@Override

protected

void onCreate(Bundle savedInstanceState) {

super .onCreate(savedInstanceState);

setContentView(R.layout. activity1 );

button =

(Button)findViewById(R.id. btn );

button .setOnClickListener( this );

text =

(TextView)findViewById(R.id. content );

}

public

void onClick(View v) {

switch (v.getId()) {

case R.id. btn :

thread = new MyThread();

thread .start();

break ;

}

}

private

class MyHandler extends Handler{

public MyHandler(Looper looper){

super (looper);

}

@Override

public

void handleMessage(Message msg) { // 处理消息

text .setText(msg. obj .toString());

}

}

private

class MyThread extends Thread{

@Override

public

void run() {

Looper curLooper = Looper.myLooper ();

Looper mainLooper = Looper.getMainLooper

();

String msg ;

if (curLooper== null ){

mHandler = new MyHandler(mainLooper);

msg = "curLooper is null" ;

} else {

mHandler = new MyHandler(curLooper);

msg = "This is curLooper" ;

}

mHandler .removeMessages(0);

Message m = mHandler .obtainMessage(1, 1, 1, msg);

mHandler .sendMessage(m);

}

}

}

说明：

Android

会自动替主线程建立Message Queue

。在这个子线程里并没有建立Message

Queue 。所以，myLooper 值为null ，而mainLooper 则指向主线程里的Looper 。于是，执行到：

mHandler = new MyHandler

(mainLooper);

此mHandler 属于主线程。

mHandler.sendMessage(m);

就将m

消息存入到主线程的Message Queue

里。mainLooper

看到Message Queue

里有讯息，就会作出处理，于是由主线程执行到mHandler 的handleMessage() 来处理消息。

用Android线程间通信的Message机制

在Android

下面也有多线程的概念，在C/C++中，子线程可以是一个函数，一般都是一个带有循环的函数，来处理某些数据，优先线程只是一个复杂的运算过程，所以可能不需要while循环，运算完成，函数结束，线程就销毁。对于那些需要控制的线程，一般我们都是和互斥锁相互关联，从而来控制线程的进度，一般我们创建子线程，一种线程是很常见的，那就是带有消息循环的线程。

消息循环是一个很有用的线程方式，曾经自己用C在Linux下面实现一个消息循环的机制，往消息队列里添加数据，然后异步的等待消息的返回。当消息队列为空的时候就会挂起线程，等待新的消息的加入。这是一个很通用的机制。

在

Android，这里的线程分为有消息循环的线程和没有消息循环的线程，有消息循环的线程一般都会有一个Looper，这个事android的新概念。我们的主线程(UI线程)就是一个消息循环的线程。针对这种消息循环的机制，我们引入一个新的机制Handle，我们有消息循环，就要往消息循环里面发送相应的消息，自定义消息一般都会有自己对应的处理，消息的发送和清除，消息的的处理，把这些都封装在Handle里面，注意Handle只是针对那些有Looper的线程，不管是UI线程还是子线程，只要你有Looper，我就可以往你的消息队列里面添加东西，并做相应的处理。

但是这里还有一点，就是只要是关于UI相关的东西，就不能放在子线程中，因为子线程是不能操作UI的，只能进行数据、系统等其他非UI的操作。

那么什么情况下面我们的子线程才能看做是一个有Looper的线程呢？我们如何得到它Looper的句柄呢？

Looper.myLooper();获得当前的Looper

Looper.getMainLooper () 获得UI线程的Lopper

我们看看Handle的初始化函数，如果没有参数，那么他就默认使用的是当前的Looper，如果有Looper参数，就是用对应的线程的Looper。

如果一个线程中调用Looper.prepare()，那么系统就会自动的为该线程建立一个消息队列，然后调用

Looper.loop();之后就进入了消息循环，这个之后就可以发消息、取消息、和处理消息。这个如何发送消息和如何处理消息可以再其他的线程中通过

Handle来做，但前提是我们的Hanle知道这个子线程的Looper，但是你如果不是在子线程运行

Looper.myLooper()，一般是得不到子线程的looper的。

public void run() {

synchronized

(mLock) {

Looper.prepare();

//do

something

}

Looper.loop();

}

所以很多人都是这样做的：我直接在子线程中新建handle，然后在子线程中发送消息，这样的话就失去了我们多线程的意义了。

class myThread extends Thread{

private

EHandler mHandler ;

public void

run() {

Looper

myLooper, mainLooper;

myLooper =

Looper.myLooper ();

mainLooper

= Looper.getMainLooper ();

String

obj;

if

(myLooper == null ){

mHandler =

new EHandler(mainLooper);

obj =

"current thread has no looper!" ;

}

else

{

mHandler =

new EHandler(myLooper);

obj = "This

is from current thread." ;

}

mHandler

.removeMessages(0);

Message m =

mHandler .obtainMessage(1, 1, 1, obj);

mHandler

.sendMessage(m);