HandlerThread见解之它不是更新ui的

古城微笑少年丶 2022-05-02 23:52 229阅读 0赞

前两天 ，看一个demo 发现了里面有使用HandlerThread。心生好奇，自己到网上看了 看资料，又翻了一下开发文档。写出来 抛砖引玉。

## HandlerThread不能更新ui ##

我第一次看见handlerThread时候，因为，他带着Handler还以为是更新UI的，其实不是的。在验证的过程中，我还发现了 我以前的一个知识点错误（受一篇博文的引导。。。）。以后，任何东西 还是自己验证一下比较好。

--------------------

首先，我先来说HandlerThread是啥。通俗的来说就是**一个子线程具有了 looper和handler这样的机制 ，当这个子线程创建了handler的时候，别的线程可以通过handler来发送信息，并且可以在这个handler里面执行耗时的操作，除了不能更新ui**，这样的机制，我们自己也可以通过

Looper.prepare();
    Handler inner = new Handler() { 
        @Override
        public void handleMessage(Message msg) { 
            super.handleMessage(msg);
            System.out.println("内部handler 里面" + Thread.currentThread().getName() + " ");
            Toast.makeText(MainActivity.this,"haahh",Toast.LENGTH_LONG).show();
            textView.setText(">>>>>>>>");
        }
    };
    inner.sendEmptyMessage(1);
    Looper.loop();

不过，这样多费劲是吧。所以 谷歌给我们造了HandlerThread这个类 就是完成这样作用的。  
如果，你运行以上代码会抛出异常：  
android.view.ViewRootImpl$CalledFromWrongThreadException: Only the original thread that created a view hierarchy can touch its views.

这个就是只有主线程才能更新view。

看上面代码，我们在handleMessage(Message msg)这个方法里面 想更新 **textView.setText(">>>>>>>>")**。所以报错 了。**这个首先说明了子线程联系的handler是不能更新线程的**。

**不过，如果 我们把textView.setText()注释的话。**

Looper.prepare();
    Handler inner = new Handler() { 
        @Override
        public void handleMessage(Message msg) { 
            super.handleMessage(msg);
            System.out.println("内部handler 里面" + Thread.currentThread().getName() + " ");
            Toast.makeText(MainActivity.this,"haahh",Toast.LENGTH_LONG).show();
            //textView.setText(">>>>>>>>");
        }
    };
    inner.sendEmptyMessage(1);
    Looper.loop();

**运行 你会发现toast弹出了！！！！**

这是怎么回事了？首先，我们看toast的show方法![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ExMDY0MDcyNTEw_size_27_color_FFFFFF_t_70]  
看我划红线的地方。service服务。我们看一下 getService()方法  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ExMDY0MDcyNTEw_size_27_color_FFFFFF_t_70 1]  
我们可以看见 返回了 INotificationManager对象的静态实例。那么这个INotificationManager是什么呢。看上面的英文注释。翻译一下的意思是：

下面的所有内容都是与通知服务的交互，通知服务处理这些系统范围内的正确排序。

这个呢 我们可以发现通知服务，其实到这里呢，应该有人就明白了。Android 有一个专门的后台服务Service 来进行Toast 等一些通知的显示 弹出。 而我们知道在Service里面 我们是可以弹出Toast的。所以 ，这个说明了 **一些通知信息的显示，都是由后台的 Service来承担的。我们在前台 只是一个通知作用**

## 上面略微跑题 ##

接下来 我们来说HandlerThread

HandlerThread handlerThread = new HandlerThread("first");
    handlerThread.start();
    
    final Handler handler = new Handler(handlerThread.getLooper(),new HandlerCallback()) { 
        int count = 0;
        @Override
        public void handleMessage(Message msg) { 
            super.handleMessage(msg);
            Toast.makeText(MainActivity.this,"haahh",Toast.LENGTH_LONG).show();
            textView.setText(">>>>>>");
        }
    };

如果，我们这么用代码的会和上面抛出一样的错误。因为这段代码和上面那段代码的作用是相同的。所以**HandlerThread是不能更新UI的**

--------------------

正确使用是 我们仍然需要主线程的handler来更新ui，HandlerThread来接受其他子线程发送过来的消息，这些消息的处理不需要更新ui

//这个是主线程Handler 实例 还有一个知识点就是如果new Handler时候没有给她传递looper的话，他会默认的去当前运行线程的looper进行联系
           MainHandler mainHandler = new MainHandler(this);
    
    
           HandlerThread handlerThread = new HandlerThread("first");
           handlerThread.start();
            //这是子线程联系的handler 传入了handlerThread的looper
            final Handler childHandler = new Handler(handlerThread.getLooper()) { 
                int count = 0;
                @Override
                public void handleMessage(Message msg) { 
                    super.handleMessage(msg);
                    System.out.println("子线程 的handler 接受到数据 现在 将数据发送给 主线程 执行 "+Thread.currentThread().getName());
                    //发送消息给 主线程的handler 让她更新ui
                    Message.obtain(mainHandler, 1, ++count).sendToTarget();
                }
            };
    
    
    
        // 开启一个子线程 调用childHandler 发送信息 
        button.setOnClickListener(new View.OnClickListener() { 
             @Override
            public void onClick(View v) { 
    
               new Thread(new Runnable() { 
                  @Override
                   public void run() { 
                    System.out.println("子线程发送数据 " +  Thread.currentThread().getName());
                    //发送给handlerThread的handler 
                     childHandler.sendEmptyMessage(1);
                  }
             }).start();
         }
      });
    
    
        //这个是主线程的Handler 定义成这种形式，可以防止内存泄露
       static class MainHandler extends Handler{ 
            private WeakReference<MainActivity> mainActivityWeakReference;
            
            MainHandler(MainActivity mainActivity) { 
                this.mainActivityWeakReference =new WeakReference<>(mainActivity);
            }
    
            @Override
            public void handleMessage(Message msg) { 
                super.handleMessage(msg);
                mainActivityWeakReference.get().textView.setText(msg.obj+"");
            }
        }

在上面我们可以看见，我们开启了一个子线程，在子线程里面调用了 HandlerThread的childHandler发送信息，childHandler接受到消息，**再调用主线程的mainHandler刷新ui**。

通过上面的例子来看 ，大家肯定感觉 这不是多此一举么。一开始 我也是这么想的，后来 我仔细思考，这个HandlerThread 其实可以应用于这些情况下面：

1.  比如，你同时有好几个子线程，你需要得到他们运算时候发出的信息，以前使用接口回调，还得实现的 ，如果 好几个子线程 岂不是要好几个接口。
2.  比如 还有 一个子线程运算完 你想知道结果，也可以通过这个来实现。以前你使用callable，接口的话 也还是 比较复杂一点的。

## 小提示 ##

public Handler(Looper looper, Callback callback)

这个handler的构造方法中的callback 官方是这么说的

在实例化处理程序时可以使用回调接口，以避免必须实现自己的处理程序子类。

简而言之呢，就是 你可以实现这个回调接口，这样你在实例化handler时候，就不要重写handleMessag()这个方法了。

//在实例化处理程序时可以使用回调接口，以避免必须实现自己的处理程序子类。
        private class HandlerCallback implements Handler.Callback { 
            @Override
            public boolean handleMessage(Message msg) { 
                System.out.println("我是handler Callback " + Thread.currentThread().getName());
                //返回true意味着即使子类重写了handlerMessage方法 也不会被调用。
                //返回false 如果有子类的话，会调用handlerMessager方法
                return true;
            }
        }

callback 已经实现了 handler方法

还有 调用HandlerThread的handler.post(Runnable) 也是在 子线程 运行的。

贴上全部代码

package com.example.handlerthread;
    
    import android.os.Handler;
    import android.os.HandlerThread;
    import android.os.Message;
    import android.support.v7.app.AppCompatActivity;
    import android.os.Bundle;
    import android.view.View;
    import android.widget.Button;
    import android.widget.TextView;
    import android.widget.Toast;
    
    import java.lang.ref.WeakReference;
    
    public class MainActivity extends AppCompatActivity { 
        private TextView textView;
        private Button   button;
    
        MainHandler mainHandler = new MainHandler(this);
    
        @Override
        protected void onCreate(Bundle savedInstanceState) { 
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
            textView = findViewById(R.id.text);
            button = findViewById(R.id.button);
            HandlerThread handlerThread = new HandlerThread("first");
            handlerThread.start();
    
            final Handler childHandler = new Handler(handlerThread.getLooper(), new HandlerCallback()) { 
                int count = 0;
    
                @Override
                public void handleMessage(Message msg) { 
                    super.handleMessage(msg);
                    System.out.println("子线程 的handler 接受到数据 现在 将数据发送给 主线程 执行 " + Thread.currentThread().getName());
                    Message.obtain(mainHandler, 1, ++count).sendToTarget();
                }
            };
            
            button.setOnClickListener(new View.OnClickListener() { 
                @Override
                public void onClick(View v) { 
    
                    new Thread(new Runnable() { 
                        @Override
                        public void run() { 
                            System.out.println("子线程发送数据 " + Thread.currentThread().getName());
                            childHandler.sendEmptyMessage(1);
                        }
                    }).start();
                }
            });
        }
        //这个是主线程的Handler 定义成这种形式，可以防止内存泄露
        static class MainHandler extends Handler { 
            private WeakReference<MainActivity> mainActivityWeakReference;
    
    
            MainHandler(MainActivity mainActivity) { 
                this.mainActivityWeakReference = new WeakReference<>(mainActivity);
            }
    
            @Override
            public void handleMessage(Message msg) { 
                super.handleMessage(msg);
                mainActivityWeakReference.get().textView.setText(msg.obj + "");
            }
        }
    
        //在实例化处理程序时可以使用回调接口，以避免必须实现自己的处理程序子类。
        private class HandlerCallback implements Handler.Callback { 
            @Override
            public boolean handleMessage(Message msg) { 
                System.out.println("我是handler Callback " + Thread.currentThread().getName());
                return true;
            }
        }
    }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ExMDY0MDcyNTEw_size_27_color_FFFFFF_t_70]: /images/20220503/15ce08dc60f941c8a624c2b3d7c10ca2.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ExMDY0MDcyNTEw_size_27_color_FFFFFF_t_70 1]: /images/20220503/895691df84e24eeda5eebab49dde3f84.png