Android精通之Handler讲解

╰半橙微兮° 2021-09-15 15:36 494阅读 0赞

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

一：简介

【达叔有道】软件技术人员，时代作者，从 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线程，做一些轻量级的事情
主线程：

  1. //创建一个Handler
  2. final Handler handler = new Handler(){
  3.   @Override
  4.   public void handleMessage(Message msg) {
  5.      super.handleMessage(msg);
  7.   /*
  8.     * 接到子线程发出来的消息，处理
  9.     * */
  10.      //处理消息
  11.     Log.i(TAG,"handleMessage:" + msg.what);
  13.       if (msg.what==110){
  14.         textView.setText("huang");
  15.         }
  16.      }
  17. };

子线程：

  1. /*
  2. * 有可能做大量耗时的操作
  3. * 子线程
  4.  * */
  5.   new Thread(new Runnable() {
  6.         @Override
  7.         public void run() {
  8.           try {
  9.                Thread.sleep(10000);
  10.               } catch (InterruptedException e) {
  11.                 e.printStackTrace();
  12.           }
  14.           /*
  15.            * 通知UI更新
  16.            * */
  17.            handler.sendEmptyMessage(110); 
  18.     }
  19. }).start();

三： Handler
public class Handler extends Object

导入android.os.Handler

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

处理程序：

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

  1. 调度消息和实现
  2. sendMessage(Message msg)
  3. sendMessageAtTime(Message,long)
  4. sendMessageDelayed(Message,long)
  6. sendEmptyMessage(int)
  7. post(Runnable)
  8. postAtTime(Runnable,log)
  9. postDelayed(Runnable,Object,log)
  10. //有很多方法还是要查官方文档的好
  12. SystemClock.uptimeMillis()为系统时间，给执行带来额外的延迟
  14. 这里了解一下源码里有
  15. obtainMessage（参数）
  16. what：int：要分配给返回的Message.what字段的值。
  17. arg1：int：要分配给返回的Message.arg1字段的值。
  18. arg2：int：要分配给返回的Message.arg2字段的值。
  20. //
  21. 发送消息延迟sendMessageAtTime

四：//Two

  1. public class MainActivity extends AppCompatActivity {
  2. //主线程
  3. }

在子线程中： 

  1. findViewById(R.id.button).setOnClickListener(new View.OnClickListener() {
  2.             @Override
  3.             public void onClick(View v) {
  4.                 /*
  5.                 * 有可能做大量耗时的操作
  6.                 * 子线程
  7.                 * */
  8.                 new Thread(new Runnable() {
  9.                     @Override
  10.                     public void run() {
  11.                         try {
  12.                             Thread.sleep(10000);
  13.                         } catch (InterruptedException e) {
  14.                             e.printStackTrace();
  15.                         }
  17.                         /*
  18.                         * 通知UI更新
  19.                         * */
  21.                         Message message = Message.obtain();
  22.                         message.what=1;
  23.                         message.arg1=2;
  24.                         message.arg2=3;
  25.                         message.obj=MainActivity.this;
  26.                         handler.sendMessage(message);
  28.                         //定时任务
  29.                         handler.sendMessageAtTime(message,SystemClock.uptimeMillis() + 5000);
  30.                         handler.sendMessageDelayed(message,5000);
  32.                         //运行可执行对象 消息来做
  33.                         /*handler.post(new Runnable() {
  34.                             @Override
  35.                             public void run() {
  36.                                执行代码
  37.                             }
  38.                         });*/
  39.                         final Runnable runnable = new Runnable() {
  40.                             @Override
  41.                             public void run() {
  42.                                 //执行代码
  43.                             }
  44.                         };
  45.                         handler.post(runnable);
  46.                         runnable.run();
  47.                         //定时任务
  48.                         handler.postDelayed(runnable,5000);
  50.                     }
  51.                 }).start();
  53.             }
  54.         });

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

了解一下Looper

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

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

  1. class LooperThread extends Thread {
  2. public void run() {
  3.      Looper.prepare();
  4.      Handler mHandler = new Handler() {
  5.              public void handleMessage(Message msg) {
  7.          }
  8.      };
  9.   Looper.loop();
  10. }
  11. }

六：强引用与弱引用

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

强引用（StrongReference）

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

弱引用(WeakReference)

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

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

七：防止内存泄漏： 

  1. private static class MyHandler extends Handler{
  2.  //WeakReference
  3.  WeakReference<MainActivity> weakReference;
  4.  public MyHandler(MainActivity activity){
  5.   weakReference = new WeakReference<MainActivity>(activity);
  6.  }
  7.  public void handleMessage(Message msg){
  8.   super.handleMessage(msg);
  9.    if(weakReference.get() != null){
  10.    } 
  11.  }
  12. }

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

八：例子：

  1. public class OneActivity extends Activity{
  2.  private MyHandler mHandler=new MyHandler(this);
  3.     public static class MyHandler extends Handler{
  5.         public final WeakReference<OneActivity > mWeakReference;
  7.         public DiglettHandler(OneActivity activity) {
  8.             mWeakReference = new WeakReference<>(activity);
  9.         }
  11.      @Override
  12.      public void handleMessage(Message msg) {
  13.          super.handleMessage(msg);
  15.          OneActivity activity = mWeakReference.get();
  16.     }
  17.  }
  18. }

九：复习快捷键 

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

编辑 ：达叔

定位：分享 Android&Java 知识点

发表评论

表情：
评论列表 （有 0 条评论，494人围观）

还没有评论，来说两句吧...

相关阅读

    相关 android之handler

    Android程序中一些操作是不能放在activity中的，因为非常耗时，如下载过程。这时，需要使用handler，即重新启动一个与activity并行的线程，下面是使用han

    淩亂°似流年淩亂°似流年/ 0 赞/ 398 阅读