数据同步异步加载handlerLooper

MainActivity

import android.app.Activity;
import android.os.Bundle;
import android.os.Handler;
import android.os.Looper;
import android.os.Message;
import android.util.Log;
import android.view.View;

/**
* 当点击按钮的时候&＃xff0c;由子线程向主线程传递数据
*
* &＃64;author Administrator
*
*/
public class MainActivity extends Activity {
private Handler handler &＃61; null;

&＃64;Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
}

// 点击按钮&＃xff0c;创建子线程
public void click_start(View v) {
new MyThread().start();
}

// 点击该按钮&＃xff0c;数据从主线程传递到子线程中
public void click_send(View v) {
// 由handler发送数据
Message msg &＃61; Message.obtain();//
msg.what &＃61; 1;
msg.arg1 &＃61; 100;
msg.obj &＃61; "我是从主线程中传递来的数据";
handler.sendMessage(msg);// msg:target:handler
}

// 自定义类&＃xff0c;继承Thread&＃xff0c;表示用于子线程
class MyThread extends Thread {
&＃64;Override
public void run() {
// 子线程中要执行的代码&＃xff1a;
// 用于接收主线程传来的数据
// 由handler接收处理数据就可以。
/**
* 报错信息&＃xff1a; java.lang.RuntimeException: Can&＃39;t create handler inside
* thread that has not called Looper.prepare()
*/
// 应该先执行&＃xff1a;Looper.prepare();
/**
* 表示将当前的线程升级为&＃xff1a;Looper线程
*
* 1.创建一个Looper对象。注意&＃xff1a;一个线程中只能有一个Looper对象。用ThreadLocal
*
* 2.一个Looper对象&＃xff0c;负责维护一个消息队列&＃xff1a;new MessageQueue
*/
Looper.prepare();// 将子线程升级&＃xff0c;成Looper线程。就可以操作handler对象。否则一个普通的子线程&＃xff0c;不能操作handler。
handler &＃61; new Handler() {
&＃64;Override
public void handleMessage(Message msg) {
switch (msg.what) {
case 1:
int num &＃61; msg.arg1;
String str &＃61; (String) msg.obj;
Log.i("tag", "&＃61;&＃61;&＃61;子线程&＃xff1a;" &＃43; Thread.currentThread().getId()
&＃43; ",线程名字&＃xff1a;" &＃43; Thread.currentThread().getName()
&＃43; ",数据&＃xff1a;" &＃43; num &＃43; ",str:" &＃43; str);
break;

default:
break;
}
}
};
Looper.loop();// 用于循环处理消息。
}
}

}

源码分析&＃xff1a;

class MyThread extends Thread {
&＃64;Override
public void run() {
// 子线程中要执行的代码&＃xff1a;
// 用于接收主线程传来的数据
// 由handler接收处理数据就可以。
/**
* 报错信息&＃xff1a; java.lang.RuntimeException: Can&＃39;t create handler inside
* thread that has not called Looper.prepare()
*/
// 应该先执行&＃xff1a;Looper.prepare();
/**
* 表示将当前的线程升级为&＃xff1a;Looper线程
*
* 1.创建一个Looper对象。注意&＃xff1a;一个线程中只能有一个Looper对象。用ThreadLocal
*
* 2.一个Looper对象&＃xff0c;负责维护一个消息队列&＃xff1a;new MessageQueue
*/
Looper.prepare();// 将子线程升级&＃xff0c;成Looper线程。就可以操作handler对象。否则一个普通的子线程&＃xff0c;不能操作handler。
handler &＃61; new Handler() {
&＃64;Override
public void handleMessage(Message msg) {
switch (msg.what) {
case 1:
int num &＃61; msg.arg1;
String str &＃61; (String) msg.obj;
Log.i("tag", "&＃61;&＃61;&＃61;子线程&＃xff1a;" &＃43; Thread.currentThread().getId()
&＃43; ",线程名字&＃xff1a;" &＃43; Thread.currentThread().getName()
&＃43; ",数据&＃xff1a;" &＃43; num &＃43; ",str:" &＃43; str);
break;

default:
break;
}
}
};
Looper.loop();// 用于循环处理消息。
}
}



要想通过Hanlder对象来异步处理消息&＃xff0c;必须要让handler所在的线程变为Looper线程。


一。Looper&＃xff1a;循环器
public class Looper {
//ThreadLocal线程本地变量&＃xff0c;用于为该线程中只有一个Looper对象。
static final ThreadLocal sThreadLocal &＃61; new ThreadLocal();
//Looper内部维护的消息队列
final MessageQueue mQueue;
//当前线程对象本身
final Thread mThread;


...
//用于初始化创建Looper
public static void prepare() {
prepare(true);
}
//创建Looper
private static void prepare(boolean quitAllowed) {
//从sThreadLocal线程本地变量中获取Looper。如果不为空&＃xff0c;意味着已经有Looper对象了。
if (sThreadLocal.get() !&＃61; null) {
//抛出异常
throw new RuntimeException("Only one Looper may be created per thread");
}
//创建一个Looper对象&＃xff0c;并且存入sThreadLocal线程本地变量中获取Looper
sThreadLocal.set(new Looper(quitAllowed));
}

....
//Looper的构造方法
private Looper(boolean quitAllowed) {
//同时创建该Looper对象所维护的消息队列
mQueue &＃61; new MessageQueue(quitAllowed);
mRun &＃61; true;
mThread &＃61; Thread.currentThread();
}


...
//循环工作
public static void loop() {
//获取当前的looper对象
final Looper me &＃61; myLooper();
//获取消息队列
final MessageQueue queue &＃61; me.mQueue;
//循环处理消息
for (;;) {
Message msg &＃61; queue.next(); // 从消息队列中获取消息

msg.target.dispatchMessage(msg);//将msg交给对应的handler去分发。msg.target:就是对应的handler
//handler.dispatchMessage(msg);

msg.recycle();//回收消息到消息池&＃xff0c;便于下次使用。
}

}
//从线程的本地变量中获取Looper对象
public static Looper myLooper() {
return sThreadLocal.get();
}
}




总结&＃xff1a;Looper的注意事项
1.每一个线程只能有最多一个Looper对象。
2.当创建Looper的同时&＃xff0c;MessageQueue一同被创建。
3.调用loop()方法&＃xff0c;循环从消息队列上获取消息&＃xff0c;分发给对应的handler。




-------------------------------------------------------
二。Handler&＃xff1a;异步处理者&＃xff0c;用于发送和处理消息的。

public class Handler {
//与当前的handler对象关联的消息队列
final MessageQueue mQueue;
//与handler关联的Looper对象

final Looper mLooper;

final Callback mCallback;

//创建Handler对象
public Handler() {
this(null, false);
}

public Handler(Callback callback, boolean async) {
mLooper &＃61; Looper.myLooper();
if (mLooper &＃61;&＃61; null) {
throw new RuntimeException(
"Can&＃39;t create handler inside thread that has not called Looper.prepare()");
}
mQueue &＃61; mLooper.mQueue;//将Looper维护的消息队列&＃xff0c;赋值给当前handler所关联的消息队列。
mCallback &＃61; callback;
}

..
//由handler发送消息到关联的消息队列上。
public final boolean sendMessage(Message msg)
{
return sendMessageDelayed(msg, 0);
}

public final boolean sendMessageDelayed(Message msg, long delayMillis)
{
if (delayMillis <0) {
delayMillis &＃61; 0;
}
return sendMessageAtTime(msg, SystemClock.uptimeMillis() &＃43; delayMillis);
}

public boolean sendMessageAtTime(Message msg, long uptimeMillis) {
MessageQueue queue &＃61; mQueue;
if (queue &＃61;&＃61; null) {
RuntimeException e &＃61; new RuntimeException(
this &＃43; " sendMessageAtTime() called with no mQueue");
Log.w("Looper", e.getMessage(), e);
return false;
}
return enqueueMessage(queue, msg, uptimeMillis);
}
private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
//为当前的message贴标签&＃xff1a;当前的handler对象
msg.target &＃61; this;
if (mAsynchronous) {
msg.setAsynchronous(true);
}
return queue.enqueueMessage(msg, uptimeMillis);
}


...
//分发消息:在Looper.loop()中调用。
public void dispatchMessage(Message msg) {
if (msg.callback !&＃61; null) {
handleCallback(msg);
} else {
if (mCallback !&＃61; null) {
if (mCallback.handleMessage(msg)) {
return;
}
}
handleMessage(msg);
}

}
//由接收数据的线程&＃xff0c; 重写的方法&＃xff0c;表示处理msg
public void handleMessage(Message msg) {
}

handler.post();
public final boolean post(Runnable r)
{
return sendMessageDelayed(getPostMessage(r), 0);
}
private static Message getPostMessage(Runnable r) {
Message m &＃61; Message.obtain();
m.callback &＃61; r;//重写的new Runnalbe(){public void run(){}}
return m;
}

private static void handleCallback(Message message) {
message.callback.run();//执行自己重写new Runnalbe(){public void run(){}}
}
}


Handler的属性和方法&＃xff1a;
属性&＃xff1a;
final MessageQueue mQueue;
final Looper mLooper;
final Callback mCallback;


方法&＃xff1a;5个重要方法
sendMessage(msg);
handleMessage();
post();
sendEmptyMessage();
obtainMessage();


dispatchMessage();
sendMessageDelayed();
sendMessageAtTime();


Handler的总结&＃xff1a;
注意事项&＃xff1a;
1.当创建Handler对象的时候&＃xff0c;(应该先有Looper)。那么handler对象会和Looper相关联&＃xff0c;以及和消息队列相关联。
2.handler发送消息到消息队列&＃xff0c;其实就是发送到关联的消息队列中。该消息队列是由对应的Looper维护。


三。Message

public final class Message implements Parcelable {
public int what;
public int arg1;
public int arg2;
public Object obj;
}
what
arg1
arg2
obj
方法&＃xff1a;
obtain();
setTarget(Handler target)
setData()
sendToTarget();

总结&＃xff1a;
1.每一个线程最多只能有一个Looper
2.一个looper负责维护一个MessageQueue
3.Handler必须在Looper所在的线程创建。