Android之HandlerThread源码分析和简单使用(主线程和子线程通信、子线程和子线程通信)

时间:2021-11-07 05:07:38

1、先熟悉handler方式实现主线程和子线程互相通信方式,子线程和子线程的通信方式

      如果不熟悉或者忘记了,请参考我的这篇博客     Android之用Handler实现主线程和子线程互相通信以及子线程和子线程之间的通信    http://blog.csdn.net/u011068702/article/details/75577005




2、贴上简单HandlerThread简单使用(主线程和子线程通信、子线程和子线程通信)的例子

1、activity_main.xml文件

<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:paddingBottom="@dimen/activity_vertical_margin"
android:paddingLeft="@dimen/activity_horizontal_margin"
android:paddingRight="@dimen/activity_horizontal_margin"
android:paddingTop="@dimen/activity_vertical_margin"
tools:context="com.example.handler.MainActivity1" >

<Button
android:id="@+id/button1"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="ParentToChile" />
<Button
android:layout_below="@+id/button1"
android:id="@+id/button2"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="ChileToParent" />
<Button
android:layout_below="@+id/button2"
android:id="@+id/button3"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="ChileToChile" />

</RelativeLayout>

2、MainActivity.java文件

package com.example.handler;

import android.os.Bundle;
import android.os.Handler;
import android.os.HandlerThread;
import android.os.Looper;
import android.os.Message;
import android.support.v7.app.ActionBarActivity;
import android.util.Log;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;

public class MainActivity extends ActionBarActivity {

public static final String TAG = "HandlerTest";
public HandlerThread mHandlerThread;
public Handler mChileHandler;
public Handler mHandlerCToP = new Handler(){
@Override
public void handleMessage(Message msg) {
super.handleMessage(msg);
int id = (int) Thread.currentThread().getId();
Log.d(TAG, "mHandlerCToP currentThread id is:" + id);
}
};
public Button mButtonPtoC;
public Button mButtonCtoP;
public Button mButtonCtoC;

public Handler mHandler = new Handler();
public Handler mHandlerCtoC = null;


@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);

int id = (int) Thread.currentThread().getId();
Log.d(TAG, "onCreate currentThread id is:" + id);

initUIAndThread();
}

public void initUIAndThread() {
mHandlerThread = new HandlerThread("chenyu");
mHandlerThread.start();
mHandler = new Handler(mHandlerThread.getLooper()) {
@Override
public void handleMessage(Message msg) {
int id = (int) Thread.currentThread().getId();
Log.d(TAG, "initThread() mHandler handleMessage currentThread id is:" + id);
switch(msg.what) {
case 0:
mHandlerCToP.post(new Runnable(){
@Override
public void run() {
int id = (int) Thread.currentThread().getId();
Log.d(TAG, "initThread() mHandlerCToP post currentThread id is:" + id);
mButtonPtoC.setText("chenyu");
}
});
break;
case 1:
mHandlerCToP.post(new Runnable(){
@Override
public void run() {
int id = (int) Thread.currentThread().getId();
Log.d(TAG, "initThread() mHandlerCToP post currentThread id is:" + id);
mButtonCtoC.setText("chenyu");
}
});
default:
break;
}
}
};

mButtonPtoC = (Button)findViewById(R.id.button1);
mButtonCtoP = (Button)findViewById(R.id.button2);
mButtonCtoC = (Button)findViewById(R.id.button3);

mButtonPtoC.setOnClickListener(new OnClickListener(){
@Override
public void onClick(View v) {
int id = (int) Thread.currentThread().getId();
Log.d(TAG, "mButtonPtoC currentThread id is:" + id);
Log.d(TAG, "mHandlerPToc msg.what is 0");
mHandler.sendEmptyMessage(0);
}
});

mButtonCtoP.setOnClickListener(new OnClickListener(){
@Override
public void onClick(View v) {
int id = (int) Thread.currentThread().getId();
Log.d(TAG, "mButtonCtoP currentThread id is:" + id);
Log.d(TAG, "mHandlerPToc msg.what is 0");
mHandlerCToP.sendEmptyMessage(0);
}
});

mButtonCtoC.setOnClickListener(new OnClickListener(){
@Override
public void onClick(View v) {
new Thread(new Runnable(){
@Override
public void run() {
int id = (int) Thread.currentThread().getId();
Log.d(TAG, "mButtonCtoC currentThread id is:" + id);
Log.d(TAG, "mHandlerCToc msg.what is 1");
mHandler.sendEmptyMessage(1);
}
}).start();
}
});
}

@Override
protected void onDestroy() {
super.onDestroy();
mHandlerThread.quit();
}
}





3、简单分析例子

   1)、原始页面效果

         Android之HandlerThread源码分析和简单使用(主线程和子线程通信、子线程和子线程通信)

    2)、控制台初始化打印的线程ID

        Android之HandlerThread源码分析和简单使用(主线程和子线程通信、子线程和子线程通信)

       分析:在onCreate方法里面打印的主线程的Id为1,有3个按钮,分别是主线程向子线程发消息,子线程向主线程发消息,子线程和子线程发送消息,我们一开始就是对HandlerThread进程初始化,其实它就是一个线程,后面会分析,然后执行了start方法,我们把HandlerThread的looper对象传递给了Handler,之前的文章已分析,一个线程只能有一个looper对象,Handler拥有了HandlerThread的looper对象,就相当于这个Handler在HandlerThread线程同样的线程Id,可以理解为Handler 在子线程里面构建,为什么我这里还有其它的Handler构建,因为想搞清楚在哪里构建属于哪个线程以及子线程的handler是否可以更新UI,主线程构建的handler是否可以更新UI,

    3)、依次点击3个按钮后控制台打印的日志

        Android之HandlerThread源码分析和简单使用(主线程和子线程通信、子线程和子线程通信)

     我们可以看到在onCreate方法里面始化handler的时候传递了一个HandlerThread的looper对象,点击第一个按钮后后没有开启线程,当前线程依然是主线程,handler发送了一个消息,然后初始化的handlMessage收到消息了,也就完成了主线程到子线程的通信,当收到消息的时候,我们发现线程的id是6314,所以这个时候虽然是在onCreate里面构建的handler里面的handlerMessage方法,但是线程Id是和HandlerThread线程Id是一样的,然后初始化handler去更新界面,我们代码是用mHandlerCtopP去更新的,因为它的初始化是在主线程构建的,所以可以post可以更新UI,但是这个时候用拥有HandlerThread的looper对象的handler更新界面就会出问题,和子线程里面的handler去更新界面异常一样,如下图

Android之HandlerThread源码分析和简单使用(主线程和子线程通信、子线程和子线程通信)


然后点击第二个按钮,是现实子线程向主线程通信,我们发现点击时间里面的线程Id,和handler收到消息的 handleMessage方法里面的线程id, 都是一样,和主线程Id一样,所以我们可以用这个handler直接post来更新UI,

点击第三个按钮,是实现子线程和子线程的通信,执行点击方法,我们开启了一个线程,自然线程Id会和主线程的不一样,为6318, handler收到消息的 handleMessage方法里面的线程id为6314,所以这里可以理解为为子线程线程里面构建了handler,然后用主线程构建的handler更新ui


   4)、依次点击3个按钮后手机效果

      Android之HandlerThread源码分析和简单使用(主线程和子线程通信、子线程和子线程通信)





4、HandlerThread.java源码分析

    1、上源代码

     

package android.os;

/**
* Handy class for starting a new thread that has a looper. The looper can then be
* used to create handler classes. Note that start() must still be called.
*/
public class HandlerThread extends Thread {
int mPriority;
int mTid = -1;
Looper mLooper;

public HandlerThread(String name) {
super(name);
mPriority = Process.THREAD_PRIORITY_DEFAULT;
}

/**
* Constructs a HandlerThread.
* @param name
* @param priority The priority to run the thread at. The value supplied must be from
* {@link android.os.Process} and not from java.lang.Thread.
*/
public HandlerThread(String name, int priority) {
super(name);
mPriority = priority;
}

/**
* Call back method that can be explicitly overridden if needed to execute some
* setup before Looper loops.
*/
protected void onLooperPrepared() {
}

@Override
public void run() {
mTid = Process.myTid();
Looper.prepare();
synchronized (this) {
mLooper = Looper.myLooper();
notifyAll();
}
Process.setThreadPriority(mPriority);
onLooperPrepared();
Looper.loop();
mTid = -1;
}

/**
* This method returns the Looper associated with this thread. If this thread not been started
* or for any reason is isAlive() returns false, this method will return null. If this thread
* has been started, this method will block until the looper has been initialized.
* @return The looper.
*/
public Looper getLooper() {
if (!isAlive()) {
return null;
}

// If the thread has been started, wait until the looper has been created.
synchronized (this) {
while (isAlive() && mLooper == null) {
try {
wait();
} catch (InterruptedException e) {
}
}
}
return mLooper;
}


public boolean quit() {
Looper looper = getLooper();
if (looper != null) {
looper.quit();
return true;
}
return false;
}


public boolean quitSafely() {
Looper looper = getLooper();
if (looper != null) {
looper.quitSafely();
return true;
}
return false;
}

/**
* Returns the identifier of this thread. See Process.myTid().
*/
public int getThreadId() {
return mTid;
}
}

1、我们知道这个类在android.os目录下,然后继承了Thread,也就是一个线程

2、构造方法会传一个字符串,这里可以随便写,只作为一个标识而已,初始化的时候会调用start方法,然后会执行run()方法

    @Override
public void run() {
mTid = Process.myTid();
Looper.prepare();
synchronized (this) {
mLooper = Looper.myLooper();
notifyAll();
}
Process.setThreadPriority(mPriority);
onLooperPrepared();
Looper.loop();
mTid = -1;
}

先执行了Looper,prepare(),然后给当前mLooper赋值,然后进行Looper.loop(),进行轮寻,这个代码和标准的子线程用handler的方式差不多,也可以理解为这种方式的封装,所以才能显示子线程和子线程和主线程之间的通信,原理都是一样。

3、getLooper()中有个wait(),这有什么用呢?因为的mLooper在一个线程中执行创建,而我们的handler是在UI线程中调用getLooper()初始化的,必须等到mLooper创建完成,才能正确的返回。getLooper();wait(),notify()就是为了解决这两个线程的同步问题。


4、这里有个退出的方法是

    public boolean quit() {
Looper looper = getLooper();
if (looper != null) {
looper.quit();
return true;
}
return false;
}

我之前写代码的时候,以为停止线程就调用了,mHandlerThread.stop()方法,后面没发现什么问题,直到我们有个功能需要,从控制台下发消息让手机恢复默认出场,函数执行到了这里,导致进程崩溃了,然后就发现这里有问题,需要调用mHandlerThread.quit()方法正常退出。




5、总结

      有时还需要频繁更新UI,或则主线程向子线程通信,以及子线程和子线程经常通信的时候,我们可以使用HandlerThread,如果哪里没说清楚,或则讲得有问题,欢迎点评