Android精通之Handler讲解

版权声明：未经博主允许不得转载

一：简介

【达叔有道】软件技术人员，时代作者，从 Android 到全栈之路，我相信你也可以！阅读他的文章，会上瘾！You and me, we are family !

二：重点

那么什么是Handler呢？为什么要使用Handler呢？如何去实现呢？我们要了解Handler的工作原理在学Handler中，我们要知道并学习Handler,Looper,MessageQueue,Message等知识点。

消息循环机制

Handler

1.Looper循环者

2.Message消息

3.MessageQueue消息队列（专门存放消息的）

一：在Handler学习中，主要了解Handler,Looper,MessageQueue,Message,Handler的作用将Message对象发送到MessageQueue中，Looper的作用像个发动机，从MessageQueue中取出数据交给Handler中的handleMessage方法。

Handler的方法以及使用

1.Handler.sendMessage()

2.Handler.post()

二：在onCreate中为主线程/UI线程，做一些轻量级的事情
主线程：

//创建一个Handler
final Handler handler = new Handler(){
  @Override
  public void handleMessage(Message msg) {
     super.handleMessage(msg);

  /*
    * 接到子线程发出来的消息，处理
    * */
     //处理消息
    Log.i(TAG,"handleMessage:" + msg.what);

      if (msg.what==110){
        textView.setText("huang");
        }
     }
};

子线程：

/*
* 有可能做大量耗时的操作
* 子线程
 * */
  new Thread(new Runnable() {
        @Override
        public void run() {
          try {
               Thread.sleep(10000);
              } catch (InterruptedException e) {
                e.printStackTrace();
          }

          /*
           * 通知UI更新
           * */
           handler.sendEmptyMessage(110); 
    }
}).start();

三： Handler
public class Handler extends Object

导入android.os.Handler

//子类
[AsyncQueryHandler][AsyncQueryHandler.WorkerHandler][HttpAuthHandler][SslErrorHandler]

处理程序：

处理Message与线程关联的Runnable对象MessageQueue，第一，安排将要执行的消息和可执行的程序；二，在不用的线程执行任务。

调度消息和实现
sendMessage(Message msg)
sendMessageAtTime(Message,long)
sendMessageDelayed(Message,long)

sendEmptyMessage(int)
post(Runnable)
postAtTime(Runnable,log)
postDelayed(Runnable,Object,log)
//有很多方法还是要查官方文档的好

SystemClock.uptimeMillis()为系统时间，给执行带来额外的延迟

这里了解一下源码里有
obtainMessage（参数）
what：int：要分配给返回的Message.what字段的值。
arg1：int：要分配给返回的Message.arg1字段的值。
arg2：int：要分配给返回的Message.arg2字段的值。

//
发送消息延迟sendMessageAtTime

四：//Two

public class MainActivity extends AppCompatActivity {
//主线程
}

在子线程中：

findViewById(R.id.button).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                /*
                * 有可能做大量耗时的操作
                * 子线程
                * */
                new Thread(new Runnable() {
                    @Override
                    public void run() {
                        try {
                            Thread.sleep(10000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }

                        /*
                        * 通知UI更新
                        * */
                    
                        Message message = Message.obtain();
                        message.what=1;
                        message.arg1=2;
                        message.arg2=3;
                        message.obj=MainActivity.this;
                        handler.sendMessage(message);

                        //定时任务
                        handler.sendMessageAtTime(message,SystemClock.uptimeMillis() + 5000);
                        handler.sendMessageDelayed(message,5000);

                        //运行可执行对象 消息来做
                        /*handler.post(new Runnable() {
                            @Override
                            public void run() {
                               执行代码
                            }
                        });*/
                        final Runnable runnable = new Runnable() {
                            @Override
                            public void run() {
                                //执行代码
                            }
                        };
                        handler.post(runnable);
                        runnable.run();
                        //定时任务
                        handler.postDelayed(runnable,5000);

                    }
                }).start();

            }
        });

五：
在子线程中先调用 Looper.prepare()，然后Handler handler = new Handler();//...//Looper.loop();

了解一下Looper

Looper为线程运行消息循环的类。线程默认情况下没有与它们相关的消息循环;创建一个，在要运行循环的线程中调用prepare（），然后让loop()处理，直到循环停止。

与消息循环的大多数交互是通过Handler类。

class LooperThread extends Thread {
public void run() {
     Looper.prepare();
     Handler mHandler = new Handler() {
             public void handleMessage(Message msg) {
                 
         }
     };
  Looper.loop();
}
}

六：强引用与弱引用

什么是强引用和弱引用呢？对象的引用机制，使得程序能够灵活地控制对象的生命周期。

强引用（StrongReference）

强引用可以理解为我们生活中必不可少的东西，如你的手机，当你空间不足时（占用空间），你也不会丢弃它，宁可抛出异常，在Java中最为常见的对象，只要此引用存在并且没有被释放就不会被垃圾回收机制回收，只有当释放了，才可能回收。

弱引用(WeakReference)

弱引用即是生活中可有可无的东西，在Java中如果一个对象具备弱引用，那么不管空间是否足够都会被回收。

//创建一个对象
Person person=new Person();
WeakReference<Person> weakPerson=new WeakReference<Person>(person);

七：防止内存泄漏：

private static class MyHandler extends Handler{
 //WeakReference
 WeakReference<MainActivity> weakReference;
 public MyHandler(MainActivity activity){
  weakReference = new WeakReference<MainActivity>(activity);
 }
 public void handleMessage(Message msg){
  super.handleMessage(msg);
   if(weakReference.get() != null){
   } 
 }
}

当weakReference.get() != null,表示weakReference指向的对象activity没有被回收。
如果此方法返回为空的话，说明weakReference指向的对象activity已经被回收。
只要指向还指向就不会被回收。

八：例子：

public class OneActivity extends Activity{
 private MyHandler mHandler=new MyHandler(this);
    public static class MyHandler extends Handler{
        
        public final WeakReference<OneActivity > mWeakReference;

        public DiglettHandler(OneActivity activity) {
            mWeakReference = new WeakReference<>(activity);
        }

     @Override
     public void handleMessage(Message msg) {
         super.handleMessage(msg);

         OneActivity activity = mWeakReference.get();
    }
 }
}

九：复习快捷键

Ctrl+n 查找类
Ctrl+Alt+L 格式化代码
Ctrl+d 复制行
Ctrl+y 删除行

编辑 ：达叔

定位：分享 Android&Java 知识点