1.概述
在android中Toast经常会被用到，在主线程中直接使用Toast没任何问题，消息显示正常。一旦将Toast放入子线程中的时候，消息不会有任何响应。网上查了解决办法，直接将写在子线程中的Toast前后加上Looper.prepare(),其后加上Looper.loop(),就可以正常显示了。例：
new Thread() {
@Override
public void run() {
Looper.prepare();
Toast.makeText(getApplicationContext(), "发生未知错误！", Toast.LENGTH_SHORT).show();
Looper.loop();
}
}.start();原来一直是只知其然不知其所以然，现在就看下内在原理，彻底了解为什么。（不建议这么使用，会造成新的问题。当前子线程因为looper的存在，导致一直处于未销毁状态，而占有内存。建议直接将消息发送到UI线程中进行显示。）
2.Looper
首先，来了解下Looper。
看看关于looper这个类的描述说明。
* Class used to run a message loop for a thread. Threads by default do
* not have a message loop associated with them; to create one, call
* {@link #prepare} in the thread that is to run the loop, and then
* {@link #loop} to have it process messages until the loop is stopped.
*
* <p>Most interaction with a message loop is through the
* {@link Handler} class.(大意就是，looper这个类是用来给线程thread运行消息循环的。线程们在默认情况下并没有一个消息循环loop与它们相关联；用looper类中的方法prepare可以在线程中创建一个looper对象用来执行loop用的，然后调用loop方法时就会让之前创建的looper对象来处理循环中的消息，直到循环停止。
Looper与消息循环的大部分交互是通过Handler类。)
看到这，就可以知道looper主要的方法就prepare()和loop()。
1.Looper.prepare()
static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>(); private Looper(boolean quitAllowed) {
mQueue = new MessageQueue(quitAllowed);
mThread = Thread.currentThread();
}
public static void prepare() {
prepare(true);
}
private static void prepare(boolean quitAllowed) {
if (sThreadLocal.get() != null) {//第5行
throw new RuntimeException("Only one Looper may be created per thread");
}
sThreadLocal.set(new Looper(quitAllowed));
}
从第5行可以看出Looper.prepare()方法中，首先会判断sThreadLocal中是否已经有Looper存在，如果有就抛异常，没有就实例化一个looper set进去。从这就可以看出每个线程中只可能存在一个Looper。
实例化Looper时，会创建一个MessageQueue，同时将当前线程和Looper绑定。
2.Looper.loop()
public static void loop() {
final Looper me = myLooper();
if (me == null) {
throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
}
final MessageQueue queue = me.mQueue;
// Make sure the identity of this thread is that of the local process,
// and keep track of what that identity token actually is.
Binder.clearCallingIdentity();
final long ident = Binder.clearCallingIdentity();
for (;;) {
Message msg = queue.next(); // might block
if (msg == null) {
// No message indicates that the message queue is quitting.
return;
}
// This must be in a local variable, in case a UI event sets the logger
final Printer logging = me.mLogging;
if (logging != null) {
logging.println(">>>>> Dispatching to " + msg.target + " " +
msg.callback + ": " + msg.what);
}
final long traceTag = me.mTraceTag;
if (traceTag != 0) {
Trace.traceBegin(traceTag, msg.target.getTraceName(msg));
}
try {
msg.target.dispatchMessage(msg);
} finally {
if (traceTag != 0) {
Trace.traceEnd(traceTag);
}
}
if (logging != null) {
logging.println("<<<<< Finished to " + msg.target + " " + msg.callback);
}
// Make sure that during the course of dispatching the
// identity of the thread wasn't corrupted.
final long newIdent = Binder.clearCallingIdentity();
if (ident != newIdent) {
Log.wtf(TAG, "Thread identity changed from 0x"
+ Long.toHexString(ident) + " to 0x"
+ Long.toHexString(newIdent) + " while dispatching to "
+ msg.target.getClass().getName() + " "
+ msg.callback + " what=" + msg.what);
}
msg.recycleUnchecked();
}
} public static @Nullable Looper myLooper() {
return sThreadLocal.get();
}在调用looper.loop()方法时，首先会从sThreadLocal中取出之前在prepare()方法中set的Looper对象。如果sThreadLocatl中没有Looper对象，就会抛异常，这就说明loop()方法必须在prepare()方法之后。
然后获取到当前Looper的MessageQueue.
之后追踪当前线程的标识。(只是用来提示一个WTF级别的日志)
开始进入死循环，每次循环开始都会调用MessageQueue.next()方法从中取出一个Message，然后将它传递到msg.target的dispatchMessage(msg)中。msg.target就是消息的接收者，其实就是一个Handler。如果消息队列MessageQueue为空，next()就会进入阻塞状态，直到有新的消息到达才会继续执行。
看看msg.target.dispathchMessage()方法
public void dispatchMessage(Message msg) {
if (msg.callback != null) {
handleCallback(msg);
} else {
if (mCallback != null) {
if (mCallback.handleMessage(msg)) {
return;
}
}
handleMessage(msg);
}
}通过looper类的说明，了解了looper的原理与使用机制。其中很重要的是，looper是用来给线程处理消息用的，线程默认情况下没有looper对象，也就是线程中的消息不会被处理，自然将消息直接丢在线程中的时候是不会被处理的。必须在线程中创建一个Looper实例，同时创建了一个消息队列（MessageQueue），然后通过无限循环取出消息交由handlerMessage处理，也就是发送消息的对象handler。
说到这里，说明了looper在handler，messageQueue之间的关系，那和Toast有什么关系呢？
3.Toast
我们再使用Toast的时候，一般形式都是：
Toast.makeText(context, msg, Toast.LENGTH_SHORT).show(); public static Toast makeText(Context context, CharSequence text, @Duration int duration) {
Toast result = new Toast(context);
LayoutInflater inflate = (LayoutInflater)
context.getSystemService(Context.LAYOUT_INFLATER_SERVICE);
View v = inflate.inflate(com.android.internal.R.layout.transient_notification, null);
TextView tv = (TextView)v.findViewById(com.android.internal.R.id.message);
tv.setText(text);
result.mNextView = v;
result.mDuration = duration;
return result;
}那我们主要就看show方法。
public void show() {
if (mNextView == null) {
throw new RuntimeException("setView must have been called");
}
INotificationManager service = getService();
String pkg = mContext.getOpPackageName();
TN tn = mTN;
tn.mNextView = mNextView;
try {
service.enqueueToast(pkg, tn, mDuration);
} catch (RemoteException e) {
// Empty
}
}我们看TN
public Toast(Context context) {
mContext = context;
mTN = new TN();
mTN.mY = context.getResources().getDimensionPixelSize(
com.android.internal.R.dimen.toast_y_offset);
mTN.mGravity = context.getResources().getInteger(
com.android.internal.R.integer.config_toastDefaultGravity);
}接下来看TN类。
private static class TN extends ITransientNotification.Stub {
final Runnable mHide = new Runnable() {
@Override
public void run() {
handleHide();
// Don't do this in handleHide() because it is also invoked by handleShow()
mNextView = null;
}
};
private final WindowManager.LayoutParams mParams = new WindowManager.LayoutParams();
final Handler mHandler = new Handler() {
@Override
public void handleMessage(Message msg) {
IBinder token = (IBinder) msg.obj;
handleShow(token);
}
};
int mGravity;
int mX, mY;
float mHorizontalMargin;
float mVerticalMargin;
View mView;
View mNextView;
int mDuration;
WindowManager mWM;
static final long SHORT_DURATION_TIMEOUT = 5000;
static final long LONG_DURATION_TIMEOUT = 1000;
TN() {
// XXX This should be changed to use a Dialog, with a Theme.Toast
// defined that sets up the layout params appropriately.
final WindowManager.LayoutParams params = mParams;
params.height = WindowManager.LayoutParams.WRAP_CONTENT;
params.width = WindowManager.LayoutParams.WRAP_CONTENT;
params.format = PixelFormat.TRANSLUCENT;
params.windowAnimations = com.android.internal.R.style.Animation_Toast;
params.type = WindowManager.LayoutParams.TYPE_TOAST;
params.setTitle("Toast");
params.flags = WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON
| WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE
| WindowManager.LayoutParams.FLAG_NOT_TOUCHABLE;
}
/**
* schedule handleShow into the right thread
*/
@Override
public void show(IBinder windowToken) {
if (localLOGV) Log.v(TAG, "SHOW: " + this);
mHandler.obtainMessage(0, windowToken).sendToTarget();
}
/**
* schedule handleHide into the right thread
*/
@Override
public void hide() {
if (localLOGV) Log.v(TAG, "HIDE: " + this);
mHandler.post(mHide);
}
public void handleShow(IBinder windowToken) {
if (localLOGV) Log.v(TAG, "HANDLE SHOW: " + this + " mView=" + mView
+ " mNextView=" + mNextView);
if (mView != mNextView) {
// remove the old view if necessary
handleHide();
mView = mNextView;
Context context = mView.getContext().getApplicationContext();
String packageName = mView.getContext().getOpPackageName();
if (context == null) {
context = mView.getContext();
}
mWM = (WindowManager)context.getSystemService(Context.WINDOW_SERVICE);
// We can resolve the Gravity here by using the Locale for getting
// the layout direction
final Configuration config = mView.getContext().getResources().getConfiguration();
final int gravity = Gravity.getAbsoluteGravity(mGravity, config.getLayoutDirection());
mParams.gravity = gravity;
if ((gravity & Gravity.HORIZONTAL_GRAVITY_MASK) == Gravity.FILL_HORIZONTAL) {
mParams.horizontalWeight = 1.0f;
}
if ((gravity & Gravity.VERTICAL_GRAVITY_MASK) == Gravity.FILL_VERTICAL) {
mParams.verticalWeight = 1.0f;
}
mParams.x = mX;
mParams.y = mY;
mParams.verticalMargin = mVerticalMargin;
mParams.horizontalMargin = mHorizontalMargin;
mParams.packageName = packageName;
mParams.hideTimeoutMilliseconds = mDuration ==
Toast.LENGTH_LONG ? LONG_DURATION_TIMEOUT : SHORT_DURATION_TIMEOUT;
mParams.token = windowToken;
if (mView.getParent() != null) {
if (localLOGV) Log.v(TAG, "REMOVE! " + mView + " in " + this);
mWM.removeView(mView);
}
if (localLOGV) Log.v(TAG, "ADD! " + mView + " in " + this);
mWM.addView(mView, mParams);
trySendAccessibilityEvent();
}
}
private void trySendAccessibilityEvent() {
AccessibilityManager accessibilityManager =
AccessibilityManager.getInstance(mView.getContext());
if (!accessibilityManager.isEnabled()) {
return;
}
// treat toasts as notifications since they are used to
// announce a transient piece of information to the user
AccessibilityEvent event = AccessibilityEvent.obtain(
AccessibilityEvent.TYPE_NOTIFICATION_STATE_CHANGED);
event.setClassName(getClass().getName());
event.setPackageName(mView.getContext().getPackageName());
mView.dispatchPopulateAccessibilityEvent(event);
accessibilityManager.sendAccessibilityEvent(event);
}
public void handleHide() {
if (localLOGV) Log.v(TAG, "HANDLE HIDE: " + this + " mView=" + mView);
if (mView != null) {
// note: checking parent() just to make sure the view has
// been added... i have seen cases where we get here when
// the view isn't yet added, so let's try not to crash.
if (mView.getParent() != null) {
if (localLOGV) Log.v(TAG, "REMOVE! " + mView + " in " + this);
mWM.removeViewImmediate(mView);
}
mView = null;
}
}
}package android.app;
/** @hide */
oneway interface ITransientNotification {
void show();
void hide();
} /**
* schedule handleShow into the right thread
*/
@Override
public void show(IBinder windowToken) {
if (localLOGV) Log.v(TAG, "SHOW: " + this);
mHandler.obtainMessage(0, windowToken).sendToTarget();
}
/**
* schedule handleHide into the right thread
*/
@Override
public void hide() {
if (localLOGV) Log.v(TAG, "HIDE: " + this);
mHandler.post(mHide);
}而且我们再TN类中并没有发现任何Looper.perpare()和Looper.loop()方法。所以这里的mhandler调用的就是当前线程的loop对象。
在对looper类说明的时候，知道线程本身默认是没有looper对象的，所以Toast在线程中使用的时候，必须创建一个looper对象。
到了这里，又产生一个疑问？主线程也是线程啊，为什么可以直接使用Toast？那接下来我们再看看主线程是怎么回事。
（如果想对Toast继续深入了解，可以看关于它的源码。这里只要清楚Toast就是创建了一个handler）
4.ActivityThread
ActivityThread是主线程入口的类，实际上并非线程，就只是一个final的类，不像HandlerThread类，ActivityThread并没有真正继承Thread类，只是往往运行在主线程，给人以线程的感觉，其实承载ActivityThread的主线程就是由Zygote fork而创建的进程。
ActivityThread.main()的主要代码：
//初始化Looper
Looper.prepareMainLooper();
//创建ActivityThread对象，并绑定到AMS
ActivityThread thread = new ActivityThread();
//一般的应用程序都不是系统应用，因此设置为false,在这里面会绑定到AMS
thread.attach(false);
if (sMainThreadHandler == null) {
sMainThreadHandler = thread.getHandler();
}
if (false) {
Looper.myLooper().setMessageLogging(new
LogPrinter(Log.DEBUG, "ActivityThread"));
}
// End of event ActivityThreadMain.
Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
//开启循环
Looper.loop();
throw new RuntimeException("Main thread loop unexpectedly exited");从上面的源码就可以看到。为什么我们的Toast(Hander)可以直接在主线程中直接使用了。主线程在创建的时候就直接绑定初始化了一个looper对象。
同时android的四大组件默认都是运行在主线程中的，所以handler可以直接在四大组件中直接使用。
到了这里，我们就清楚了为什么Toast在主线程中可以直接使用，在子线程中就必须初始化looper对象。
675
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
