1、先写布局，布局代码activity_main.xml:
<?xml version="1.0" encoding="utf-8"?>
<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:gravity="center"
tools:context=".MainActivity">
<Button
android:layout_centerInParent="true"
android:id="@+id/button"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="点我加载"
android:onClick="click"/>
<TextView
android:id="@+id/text"
android:layout_below="@+id/button"
android:layout_centerInParent="true"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="还没开始加载!" />
<ProgressBar
android:layout_below="@+id/text"
android:id="@+id/progress_bar"
android:layout_width="fill_parent"
android:layout_height="wrap_content"
android:progress="0"
android:max="100"
style="?android:attr/progressBarStyleHorizontal"/>
<Button
android:layout_below="@+id/progress_bar"
android:layout_centerInParent="true"
android:id="@+id/cancel"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="cancel"
android:onClick="click"/>
</RelativeLayout>
2、Thread+Handler实现异步，我用到两种方法，第一种方法是单例类结合接口回调的方式实现，第二种是静态内部类加弱引用实现。
第一种方法，单例结合接口回调：
（1）封装一个Handler的单例类MyHandler，并定义InMyHandler接口回调：
/**
* Handler单例的封装
*/
public class CustomHandler extends Handler {
private CustomHandler(){}
private static class CustomHandlerHolder{
private static final CustomHandler INSTANCE = new CustomHandler();
}
public static CustomHandler getInstance(){
return CustomHandlerHolder.INSTANCE;
}//返回线程安全的单例
@Override
public void handleMessage(Message message){//重写handleMessage方法
super.handleMessage(message);
if (inCustomHandler == null) return;
inCustomHandler.InHandleMessage(message);//调用接口方法
}
private static InCustomHandler inCustomHandler;//定义接口变量
public interface InCustomHandler{//定义接口
void InHandleMessage(Message message);//定义接口方法
}
public void setInCustomHandler(InCustomHandler inCustomHandler){//注册接口的方法
CustomHandler.inCustomHandler = inCustomHandler;//接口的引用指向它的实例化对象,传入的参数inCustomHandler为实现该接口的类的实例化对象
}
public void removeInCustomHandler(){//取消注册接口的方法
CustomHandler.inCustomHandler = null;//inCustomHandler置为null，inCustomHandler将不再持有外部类引用
}
}
（2）封装一个Thread的单例类MyThread并实现Runnable接口，定义InMyHandler接口回调：
/**
* Thread单例的封装
*/
public class MyThread extends Thread implements Runnable {
private MyThread(){}
private static class MyThreadHolder{
private static final MyThread INSTANCE = new MyThread();
}
static MyThread getInstance(){//返回线程安全的单例
return MyThreadHolder.INSTANCE;
}
@Override
public void run(){//重写run()方法
if (inMyThread!=null){
inMyThread.run();//调用接口方法
}
}
private static InMyThread inMyThread;//定义接口变量
public interface InMyThread{//定义接口
void run();//定义接口方法
}
void setInMyThread(InMyThread inMyThread){//注册接口的方法
MyThread.inMyThread = inMyThread;//接口的引用指向它的实例化对象,传入的参数inMyHandler为实现该接口的类的实例化对象
}
void removeInMyThread(){//取消注册接口的方法
MyThread.inMyThread = null;//inMyThread置为null，inMyHandler将不再持有外部类引用
}
}
（3）在MainActivity.Java中使用：
import android.os.Bundle;
import android.os.Message;
import android.view.View;
import android.widget.ProgressBar;
import android.widget.TextView;
public class ThreadActivity extends FatherActivity implements MyHandler.InMyHandler,MyThread.InMyThread{//实现InMyHandler跟InMyThread接口
//显示进度的文本
TextView text;
//进度条
ProgressBar progressBar;
//加载按钮在进度过程中的点击次数，防止没加载完再次点击了加载按钮
int tag;
//为Thread设置终止标志位
boolean isStop;
//定义全局MyHandler变量
MyHandler myHandler;
//定义全局MyThread变量
MyThread myThread;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_thread);
//获取控件
text = findViewById(R.id.text);
progressBar = findViewById(R.id.progress_bar);
tag = 0;
isStop = false;
//实例化MyHandler对象并注册InMyHandler接口
myHandler = MyHandler.getInstance();
myHandler.setInMyHandler(this);
//实例化MyThread对象并注册InMyThread接口
myThread = MyThread.getInstance();
myThread.setInMyThread(this);
}
/**
* 异步多线程：Thread+Handler
*/
//实现InMyHandler的接口方法
@Override
public void InHandleMessage(Message message){
//执行逻辑
progressBar.setProgress(message.what);
if (message.arg1==101){
if (message.what==100){
text.setText("加载完毕");
}else {
text.setText("loading..." + message.what + "%");
}
}else if (message.arg1==102){
text.setText("已取消");
}
}
//实现InMyThread的接口方法
@Override
public void run(){
//执行逻辑
try {
int count = 0;
int length = 1;
while (count<100) {
if (isStop){//点击了取消按钮，改变了标志位的值，终止当前线程
count = 100;//直接将count设置成100，跳出循环
if (myHandler!=null){
sendMessage(0,102);
}
}else {
count += length;
// 模拟耗时任务
myThread.sleep(500);
if (myHandler!=null){
sendMessage(count,101);
}
}
}
if (count==100){//重置tap和isStop
tag = 0;
isStop = false;
}
}catch (InterruptedException e) {
e.printStackTrace();
}
}
//myHandler发送message
void sendMessage(int what, int arg1){
Message message = new Message();
message.what = what;
message.arg1 = arg1;
myHandler.sendMessage(message);
}
//点击事件
public void click(View view){
switch (view.getId()){
case R.id.button:
tag++;
if (tag<2){
myThread.start();//启动线程
}
break;
case R.id.cancel:
if (tag!=0){//只有当点击了加载按钮，取消按钮才生效
isStop = true;
}
break;
}
}
@Override
protected void onDestroy() {
super.onDestroy();
isStop = true;//置为true使得Thread终止，避免内存泄漏（必要）
myHandler.removeInMyHandler();//myHandler取消注册接口，避免内存泄漏（必要）
myThread.removeInMyThread();//myThread取消注册接口，避免内存泄漏（必要）
// myHandler.removeCallbacksAndMessages(null);//销毁移除所有消息，避免内存泄露，参数null代表移除所有回调跟消息
}
}
这里说说大概思路：
（1）MainActivity分别实现InMyHandler接口和InMyThread接口
（2）分别声明两个单例对象
（3）分别实例化两个单例对象，并注册接口
（4）实现接口回调的方法
（5）启动线程
（6）最后，要特别注意的，在Activity销毁时需要将isStop置为true来终止当前线程，另外还要取消两个接口的注册，否则线程和接口会持有当前Activity的引用，使Activity不能够被回收造成内存泄漏。
注意：handler在Activity中是一个内部类并且持有activity的引用，如果activity被销毁，但是handler还在执行，那么在垃圾回收的时候就无法回收activity，就会造成内存泄漏。（在java中非静态内部类和匿名内部类都会隐式持有当前类的外部引用，由于Handler是非静态内部类所以其持有当前Activity的隐式引用，如果Handler没有被释放，其所持有的外部引用也就是Activity也不可能被释放，当一个对象不需要再使用了，本来该被回收时，而有另外一个正在使用的对象持有它的引用从而导致它不能被回收，这导致本该被回收的对象不能被回收而停留在堆内存中，这就产生了内存泄漏）
3、Thread+Handler实现异步的第二种方法，是静态内部类加弱引用实现，下面看MainActivity.java代码：
import android.content.Context;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.view.View;
import android.widget.ProgressBar;
import android.widget.TextView;
import java.lang.ref.WeakReference;
public class ThreadActivity extends FatherActivity{
//显示进度的文本
TextView text;
//进度条
ProgressBar progressBar;
//加载按钮在进度过程中的点击次数，防止没加载完再次点击了加载按钮
int tag;
//为Thread设置终止标志位
boolean isStop;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_thread);
//获取控件
text = findViewById(R.id.text);
progressBar = findViewById(R.id.progress_bar);
tag = 0;
isStop = false;
}
/**
* 异步多线程：Thread+Handler
*/
//myHandler发送message
void sendMessage(int what, int arg1){
Message message = new Message();
message.what = what;
message.arg1 = arg1;
myHandler.sendMessage(message);
}
MyHandler myHandler = new MyHandler(this);//MyHandler实例对象
static class MyHandler extends Handler {//MyHandler静态内部类
WeakReference<Context> weakReference;//弱引用对象
MyHandler(Context context) {
weakReference = new WeakReference<>(context);
}
@Override
public void handleMessage(Message msg) {
ThreadActivity threadActivity = (ThreadActivity) weakReference.get();
if (threadActivity != null) {
threadActivity.progressBar.setProgress(msg.what);
if (msg.arg1==101){
if (msg.what==100){
threadActivity.text.setText("加载完毕");
}else {
threadActivity.text.setText("loading..." + msg.what + "%");
}
}else if (msg.arg1==102){
threadActivity.text.setText("已取消");
}
}
}
}
MyRunnable myRunnable = new MyRunnable(this);//MyRunnable实例对象
static class MyRunnable extends Thread implements Runnable{//MyRunnable静态内部类
WeakReference<Context> weakReference;//弱引用对象
MyRunnable(Context context){
weakReference = new WeakReference<>(context);
}
@Override
public void run() {
ThreadActivity threadActivity = (ThreadActivity)weakReference.get();
if (threadActivity!=null){
try {
int count = 0;
int length = 1;
while (count<100) {
if (threadActivity.isStop){//点击了取消按钮，改变了标志位的值，终止当前线程
count = 100;
threadActivity.sendMessage(0,102);
}else {
count += length;
// 模拟耗时任务
Thread.sleep(500);
threadActivity.sendMessage(count,101);
}
}
if (count==100){//重置tap和isStop
threadActivity.tag = 0;
threadActivity.isStop = false;
}
}catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
//点击事件
public void click(View view){
switch (view.getId()){
case R.id.button:
tag++;
if (tag<2){
myRunnable.start();//启动线程
}
break;
case R.id.cancel:
if (tag!=0){//只有当点击了加载按钮，取消按钮才生效
isStop = true;
}
break;
}
}
@Override
protected void onDestroy() {
super.onDestroy();
isStop = true;//置为true使得Thread终止
}
}
静态的内部类是随着类的加载而加载的，不会持有外部类的引用，同时根据WeakReference弱引用的特点，在GC回收时能回收弱引用对象。
.get()方法是判断这个对象是否被回收，对象如果存在才能做后面的操作。另外有时候，我们需要在Activity的onDestroy()或者onStop()中调用myHandler.removeCallbacksAndMessages(null);来移除所有消息和Runnable，参数null代表删除所有的消息和回调。
异步消息机制
异步消息处理由 4 个部分组成。
1、 Message
Message 可以在线程之间传递消息。可以在它的内部携带少量数据，用于在不同线程之间进行数据交换。除了 what 字段，还可以使用 arg1 和 arg2 来携带整型数据，使用 obj 来携带 Object 数据。
2、 Handler
Handler 用于发送（sendMessage 系列方法）与处理消息（handleMessage 方法）。
3、MessageQueue
MessageQueue 用于存放所有通过 Handler 发送的消息 。 这部分消息会一直存放在消息队列中，直到被处理 。 每个线程中只会有一个 MessageQueue 对象 。
4、 Looper
Looper 用于管理 MessageQueue 队列，调用 Looper.loop() 方法之后，就会进入无限循环中，每当发现 MessageQueue 存在一条消息，就会将它取出，并传递到 Handler 的 handleMessage() 方法中。每个线程中只会有一个 Looper 对象。
异步消息处理流程
- 在主线程中创建 Handler 对象，并重写 handleMessage() 方法。
- 子线程进行 UI 操作时，创建 Message 对象，通过 Handler 发送这条消息。
- Looper 从 MessageQueue 中取出待处理消息。
- 最后分发回 Handler 的 handleMessage() 方法中。
其中前两步是代码可见的
网友评论