handlerthread
1. 前言
首先，看一下官方对HandlerThread的解释：
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.
翻译中文为:HandlerThread 是一个包含Looper的Thread，这个 Looper 可以被用来创建 Handler，start方法必须被调用。
我们先来看看HandlerThread的特点：
- HandlerThread继承Thread，本质还是线程类；
- HandlerThread内部创建looper对象，这个Looper对象可以被用来创建Handler，通过looper循环，可以在handleMessage方法中执行耗时任务。
- HandlerThread必须先调用HandlerThread.start()方法。
2.使用方法
1）创建HandlerThread对象
handlerThread = new HandlerThread("refreash");
2）启动HandlerThread，创建Looper
handlerThread.start();
HandlerThread必须先调用HandlerThread.start()方法，随后Thread会调用run方法，创建Looper对象。
3）HandlerThread内部创建Looper，用来新建handler对象，发送消息
handler = new MyHandler(handlerThread.getLooper());
handler.sendMessage(handler.obtainMessage());
4）handleMessage处理耗时任务
private class MyHandler extends Handler {
public MyHandler(Looper looper) {
super(looper);
}
@Override
public void handleMessage(Message msg) {
handleIntent();
sendMessage(handler.obtainMessage());
}
}
3.具体使用代码
package com.test.cyf;
import android.app.Activity;
import android.os.Bundle;
import android.os.Handler;
import android.os.HandlerThread;
import android.os.Looper;
import android.os.Message;
import android.widget.TextView;
public class MainActivity extends Activity {
private TextView amount;
/**
* 子线程
*/
private MyHandler handler;
private int size = 0;
private HandlerThread handlerThread;
private class MyHandler extends Handler {
public MyHandler(Looper looper) {
super(looper);
}
@Override
public void handleMessage(Message msg) {
handleIntent();
sendMessage(handler.obtainMessage());
}
}
/**
* 主线程刷新UI
*/
private Handler uiHandler = new Handler() {
@Override
public void handleMessage(Message msg) {
amount.setText(size + "");
super.handleMessage(msg);
}
};
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
initView();
loadData();
}
/**
* 初始化view
*/
private void initView() {
amount = (TextView) findViewById(R.id.amount);
}
/**
* 初始化数据
*/
private void loadData() {
handlerThread = new HandlerThread("refreash");
handlerThread.start();
handler = new MyHandler(handlerThread.getLooper());
handler.sendMessage(handler.obtainMessage());
}
/**
* 子线程处理耗时操作
*/
private void handleIntent() {
try {
//模拟耗时
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
size++;
Message msg = uiHandler.obtainMessage();
uiHandler.sendMessage(msg);
}
@Override
protected void onDestroy() {
handlerThread.quit();
super.onDestroy();
}
}
该程序模拟实现如下功能：子线程执行一秒的耗时操作后，数值加1并且刷新界面，如下图所示：
很明显，你也可以自己用Thread+Handler实现，只不过HandlerThread去做了封装，IntentService中使用HandlerThread是比较经典的场景，后面会讲解IntentService。
4.源码讲解
/*
* Copyright (C) 2006 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
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;
}
/**
* Quits the handler thread's looper.
* <p>
* Causes the handler thread's looper to terminate without processing any
* more messages in the message queue.
* </p><p>
* Any attempt to post messages to the queue after the looper is asked to quit will fail.
* For example, the {@link Handler#sendMessage(Message)} method will return false.
* </p><p class="note">
* Using this method may be unsafe because some messages may not be delivered
* before the looper terminates. Consider using {@link #quitSafely} instead to ensure
* that all pending work is completed in an orderly manner.
* </p>
*
* @return True if the looper looper has been asked to quit or false if the
* thread had not yet started running.
*
* @see #quitSafely
*/
public boolean quit() {
Looper looper = getLooper();
if (looper != null) {
looper.quit();
return true;
}
return false;
}
/**
* Quits the handler thread's looper safely.
* <p>
* Causes the handler thread's looper to terminate as soon as all remaining messages
* in the message queue that are already due to be delivered have been handled.
* Pending delayed messages with due times in the future will not be delivered.
* </p><p>
* Any attempt to post messages to the queue after the looper is asked to quit will fail.
* For example, the {@link Handler#sendMessage(Message)} method will return false.
* </p><p>
* If the thread has not been started or has finished (that is if
* {@link #getLooper} returns null), then false is returned.
* Otherwise the looper is asked to quit and true is returned.
* </p>
*
* @return True if the looper looper has been asked to quit or false if the
* thread had not yet started running.
*/
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）构造方法HandlerThread（String name） ；HandlerThread（String name，int priority） 传入线程名和线程等级
2）当调用handlerThread.start（）方法时，会调用HandlerThread的run（）方法，该方法会创建looper对象，设置线程等级，循环looper。
3）当创建handler对象的时候，我们会用HandlerThread的getLooper方法，该方法会返回Looper对象，但是有个wait（），什么时候唤醒呢，在HandlerThread的run（）方法中会看到notifyAll（）方法，就是等到looper创建完成，才能通过getLooper获取到，这样做是为了解决这两个线程的同步问题。
4）上面的例子代码，在ondestory方法中，调用了handlerThread的quit（）方法，quit方法中调用了looper的quit方法，把messageQueue中的message全部移除。如果我们不调用quit（）方法，子线程会一直处于等待状态，所有需要手动调用quit方法。
如有错误欢迎指出来，一起学习。
交流讨论群
群号：469890293
相关阅读
软件的下载地址： http://www.ghisler.com/download.htm http://www.gy84.com/download.php?id=2715 资源管理器 Total Commande
介绍 关于6.0运行时权限认证，使用官网介绍的方式比较繁琐，这里介绍一个开源库AndPermission，它采用链式调用方式，一句话申请所需权限
首先先查看本机是否安装了bindrpm -qa | grep bind*如果没有安装的话使用命令yum install bind轻松安装然后我们先完成在上一章提
词典：Configure：配置；设定；使成形；使具一定形式on the canvas：被击倒widget：小器具、装饰品、窗口小部件snapping：显著地、强烈地、非常地