java handlerthread_Android/java 多线程(二)-Thread的好兄弟Handler

上一篇带大家了解了Thread的使用以及基本的运行原理，这一篇就带大家了解下Thread的好兄弟Handler

简介

Handler机制在安卓中应用非常广泛，像我们常见的用于在子线程中更新UI：

public class MainActivity extends AppCompatActivity {

@SuppressLint("HandlerLeak")

private Handler mHandler = new Handler(){

@Override

public void handleMessage(Message msg) {

//更新UI

}

};

@Override

protected void onCreate(Bundle savedInstanceState) {

super.onCreate(savedInstanceState);

setContentView(R.layout.activity_main);

MyThread thread = new MyThread();

thread.start();

}

class MyThread extends Thread {

@Override

public void run() {

//处理子线程逻辑

//....

//发送消息更新UI

Message message = mHandler.obtainMessage(1);

mHandler.sendMessage(message);

}

}

}

由此引出一些问题，为什么sendMessage之后handleMessage方法会被执行?.为什么handleMessage是在主线程中?.它们的消息是如何传递的?.这些会在下面讲解

且看还有一种使用情况，在子线程中使用Handler:

public class MainActivity extends AppCompatActivity {

@Override

protected void onCreate(Bundle savedInstanceState) {

super.onCreate(savedInstanceState);

setContentView(R.layout.activity_main);

MyThread thread = new MyThread();

thread.start();

}

class MyThread extends Thread {

@Override

public void run() {

Looper.prepare();

@SuppressLint("HandlerLeak")

Handler mHandler = new Handler(){

@Override

public void handleMessage(Message msg) {

//处理逻辑

l(Thread.currentThread().getName());

}

};

Message message = mHandler.obtainMessage(1);

mHandler.sendMessage(message);

Looper.loop();

}

}

public void l(String s) {

Log.i("HJ", s);

}

}

打印结果如下：

2018-12-20 10:48:21.682 1808-1824/? I/HJ: Thread-2

如果我们不使用Looper.prepare()和Looper.loop()方法，直接运行，那么会抛出以下异常：

2018-12-20 11:00:49.654 2029-2045/com.zj.example.customview.funnel E/AndroidRuntime: FATAL EXCEPTION: Thread-2

Process: com.zj.example.customview.funnel, PID: 2029

java.lang.RuntimeException: Only one Looper may be created per thread

at android.os.Looper.prepare(Looper.java:95)

at android.os.Looper.prepare(Looper.java:90)

at com.zj.example.customview.funnel.MainActivity$MyThread.run(MainActivity.java:48)

这是为什么呢？，为什么子线程不能直接创建Handler呢？使用了Looper.prepare()和Looper.loop()为什么又可以了呢？，这两个方法又是干什么用的呢？请看以下源码分析。

原理分析

Handler机制的核心类主要有三个，Handler ,Message,Looper,而与Looper相关联的类还有ThreadLocal和MessageQueue,下面来一一介绍下它们的作用:

Message

消息的载体，内部主要存放一些消息类型，参数主要有：

(1)public int what：变量，用于定义此Message属于何种操作

(2)public Object obj：变量，用于定义此Message传递的信息数据，通过它传递信息

(3)public int arg1：变量，传递一些整型数据时使用

(4)public int arg2：变量，传递一些整型数据时使用

(5)public Handler getTarget()：普通方法，取得操作此消息的Handler对象。

在该类的使用上，尽量使用obtain()方法来获取，而非构造方法，这样可以节省内存。而在数据传递方面，如果是int类型的，建议使用arg1和arg2,其次再考虑使用Bundle

Looper

消息通道，消息机制的主要逻辑实现类，内部有使用ThreadLocal用来保存当前线程的Looper,使用MessageQueue用来维护Message池，而我们使用Looper.prepare()方法其实也就是将此线程的Looper对象加入到ThreadLocal中去：

public static void prepare() {

prepare(true);

}

private static void prepare(boolean quitAllowed) {

if (sThreadLocal.get() != null) {

//一个线程只能创建一个Looper

throw new RuntimeException("Only one Looper may be created per thread");

}

sThreadLocal.set(new Looper(quitAllowed));

}

看源码就知道，当前线程中有且只有一个Looper，当我们再次创建，就会抛出异常，所以上面抛异常的原因就是在这里。

而我们的loop()方法就是消息机制的核心，原理是实现了一个无限循环，用于从MessageQueue中取出消息分发到各个Handler中去，以下是精简源码：

public static void loop() {

//从ThreadLocal中取出Looper

final Looper me = myLooper();

if (me == null) {

throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");

}

//从Looper中获取到MessageQueue

final MessageQueue queue = me.mQueue;

........

//创建循环

for (;;) {

//从MessageQueue中一个一个的取出Message

Message msg = queue.next(); // might block

if (msg == null) {

//没消息取了就退出

return;

}

...........

final long start = (slowDispatchThresholdMs == 0) ? 0 : SystemClock.uptimeMillis();

final long end;

try {

//dispatchMessage方法的调用在这

msg.target.dispatchMessage(msg);

end = (slowDispatchThresholdMs == 0) ? 0 : SystemClock.uptimeMillis();

} finally {

if (traceTag != 0) {

Trace.traceEnd(traceTag);

}

}

.........

//回收消息，同时将Message置为空消息对象，存储在消息池中，用于obtain()方法再次获取

msg.recycleUnchecked();

}

}

综合要点就是使用loop()来开启消息分发，并且使用prepare来创建Looper。并且一个线程只能有一个Looper。

可以看到，dispatchMessage就是在这里回调的，那这个target是什么东西呢，其实就是我们的Handler对象。那这个Handler对象是在哪里赋值的呢，请看Handler源码

Handler

首先看我们的构造方法最终会调用到这里：

public Handler(Callback callback, boolean async) {

if (FIND_POTENTIAL_LEAKS) {

final Class extends Handler> klass = getClass();

if ((klass.isAnonymousClass() || klass.isMemberClass() || klass.isLocalClass()) &&

(klass.getModifiers() & Modifier.STATIC) == 0) {

Log.w(TAG, "The following Handler class should be static or leaks might occur: " +

klass.getCanonicalName());

}

}

//这里就将Looper创建好了，主要这里是在主线程中

mLooper = Looper.myLooper();

if (mLooper == null) {

throw new RuntimeException(

"Can't create handler inside thread that has not called Looper.prepare()");

}

mQueue = mLooper.mQueue;

mCallback = callback;

mAsynchronous = async;

}

这里主要起到从ThreadLocal中获取Looper对象的作用。看Looper.myLooper()方法：

/**

* Return the Looper object associated with the current thread. Returns

* null if the calling thread is not associated with a Looper.

*/

public static @Nullable Looper myLooper() {

return sThreadLocal.get();

}

随后我们会调用sendMessage()类型的方法来发送消息，最终都会调用这个方法：

private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {

msg.target = this; //这里将Handler赋值了

if (mAsynchronous) {

msg.setAsynchronous(true);

}

return queue.enqueueMessage(msg, uptimeMillis);

}

注意看这里msg.target = this，这里实现了将当前Handler赋值到了Message中。随后调用了enqueueMessage方法就将此Message投入到了消息池MessageQueue中.到这里，一系列的初始化与调用都完成了。

所以，经过以上分析，我们之前的问题就迎刃而解了，但是还是有一个问题，我们在第一个实例中并没有使用Looper的prepare和loop方法，那我们的消息机制为什么会生效呢，其实在我们的app创建的时候系统已经默认为我们开启了，并且是在主程序的最后调用的，并没有在onCreate()方法中,而其他的生命周期方法，是通过AMS进行回调。这就保证了我们的循环不会造成主线程卡顿，具体的源码调用是在ActivityThread类中的main函数中:

public static void main(String[] args) {

SamplingProfilerIntegration.start();

// CloseGuard defaults to true and can be quite spammy. We

// disable it here, but selectively enable it later (via

// StrictMode) on debug builds, but using DropBox, not logs.

CloseGuard.setEnabled(false);

Environment.initForCurrentUser();

// Set the reporter for event logging in libcore

EventLogger.setReporter(new EventLoggingReporter());

Security.addProvider(new AndroidKeyStoreProvider());

// Make sure TrustedCertificateStore looks in the right place for CA certificates

final File configDir = Environment.getUserConfigDirectory(UserHandle.myUserId());

TrustedCertificateStore.setDefaultUserDirectory(configDir);

Process.setArgV0("");

Looper.prepareMainLooper(); // //为当前线程(主线程)创建一个Looper对象

ActivityThread thread = new ActivityThread();

thread.attach(false);

if (sMainThreadHandler == null) {

sMainThreadHandler = thread.getHandler(); //为当前线程设置Handler

}

AsyncTask.init();

if (false) {

Looper.myLooper().setMessageLogging(new

LogPrinter(Log.DEBUG, "ActivityThread"));

}

Looper.loop(); // 执行从消息队列中获取Message，并调用Handler进行处理的无限循环；所有和主线程相关的消息处理都在该方法中执行

throw new RuntimeException("Main thread loop unexpectedly exited");

}

分析到这，Handler流程其实也差不多了，最后做下总结:

1.在主线程中初始化了一个Handler,此时Looper.loop()已经开启，通过Handler构造方法创建了一个在主线程中的Looper，并保存到了ThreadLocal中，此时主线程不允许再创建第二个Looper.

2.在子线程中使用sendMessage方法，此时会调用enqueueMessage()方法并创建一个Message(或从池中取出空Message对象),然后我们将需要发送的消息保存在Message中，并将此Handler保存到Message的target对象中，然后压入到MessageQueue消息池中

3.Looper中会循环从MessageQueue中取出Message对象，并回调到target对象上的Handler的dispatchMessage()方法中去，由于Looper.loop()方法是在主线程中调用，所以dispatchMessage()方法也是运行在主线程中。Looper.loop()方法运行所在的线程决定dispatchMessage()方法回调的线程，并且需要与Looper.prepare()方法配套使用