Android进阶6：ThreadHandler详解和源码分析

时间  2019-11-06
标签 android 进阶 threadhandler 详解 源码 分析 栏目 Android 繁體版
原文   原文链接

线程与线程之间的通讯

源码解读 Android 消息机制（ Message MessageQueue Handler Looper)中详细介绍了Looper，handle，Message的使用关系。java

  • 主线程和子线程
    在UI线程中，自动建立了Looper，和消息队列MessageQueue，并开启了循环。只须要在UI线程中实现Handler 的mUIHnadler,而后在某个子线程的run方法里把使用mUIHnadler.sendMessage(),便可把消息发送到UI线程的MessageQueue中，在UI线程处理消息
 //主线程
 mUIHandler = new Handler() {
              public void handleMessage(Message msg) {
                  // 这里处理消息
              }
          };
 //子线程
 class SubThread extends Thread {
      public void run() {

         //其余耗时代码
          mHandler.sendMessage(new Message());//发送到主线程处理
      }
复制代码
  • 子线程和子线程
    通常在子线程中须要显示的声明建立Looper：
 public Handler mHandler1;
 //子线程1 建立looper并循环
class LooperThread1 extends Thread {

      public void run() {
          Looper.prepare();

          mHandler = new Handler() {
              public void handleMessage(Message msg) {
                  // 这里处理消息
              }
          };

          Looper.loop();
      }
//子线程2 
class LooperThread2 extends Thread {

      public void run() {

          //线程2的其余代码

          mHandler1.sendMessage(Message.obtain());//发送到线程1的MessageQueue中，在线程1中去处理

      }
复制代码

很明显的一点就是，咱们要在子线程中调用Looper.prepare() 为一个线程开启一个消息循环，默认状况下Android中新诞生的线程是没有开启消息循环的。（主线程除外，主线程系统会自动为其建立Looper对象，开启消息循环。） Looper对象经过MessageQueue来存放消息和事件。一个线程只能有一个Looper，对应一个MessageQueue。 而后经过Looper.loop() 让Looper开始工做，从消息队列里取消息，处理消息。android

注意：写在Looper.loop()以后的代码不会被执行，这个函数内部应该是一个循环，当调用mHandler.getLooper().quit()后，loop才会停止，其后的代码才能得以运行。web

能够看到，很是繁琐，一层套一层看着也不美观。安全

HandlerThread就是为了帮咱们免去写上面那样的代码而生的网络

官方文档对它的介绍：app

HandlerThread 是一个包含 Looper 的 Thread，咱们能够直接使用这个 Looper 建立 Handler异步

HandlerThread,继承自Thread，本质是Thread,它与普通Thread的差异就在于，它有个Looper成员变量。其内部就是经过Thread+Looper来实现的，说白了HandlerThread就是Android已经封装好的一个拥有本身looper的线程，咱们能够利用它执行一些耗时任务。咱们先来看看HandlerThread的使用步骤并提供给你们一个使用案例：ide

HandlerThread的使用步骤:

  • 建立实例对象
HandlerThread handlerThread = new HandlerThread("downloadImage");  
复制代码

参数的做用主要是标记当前线程的名字，能够任意字符串。函数

  • 启动HandlerThread线程
//必须先开启线程  
  handlerThread.start();  
复制代码

到此，咱们就构建完一个循环线程。那么咱们怎么将一个耗时的异步任务投放到HandlerThread线程中去执行呢？接下来看下面步骤：oop

  • 构建循环消息处理机制
  /** 
   * 该callback运行于子线程 
   */  
  class ChildCallback implements Handler.Callback {  
      @Override  
      public boolean handleMessage(Message msg) {  
          //在子线程中进行相应的网络请求  

          //通知主线程去更新UI  
          mUIHandler.sendMessage(msg1);  
          return false;  
      }  
  }  
复制代码

构建异步handler

//子线程Handler  
Handler childHandler = new Handler(handlerThread.getLooper(),new ChildCallback());  
复制代码

第3步是构建一个能够用于异步操做的handler，并将前面建立的HandlerThread的Looper对象和Callback接口类做为参数传递给当前的handler，这样当前的异步handler就拥有了HandlerThread的Looper对象，而其中的handlerMessage方法来处理耗时任务，Looper+Handler+MessageQueue+Thread异步循环机制构建完成。下面咱们来看一个使用案例

HandlerThread的使用案例:每一个1秒去更新图片 

public class HandlerThreadActivity extends Activity {
    /**
     * 图片地址集合,图片来自网络.
     */
    private String url[]={
            "http://img.my.csdn.net/uploads/201407/26/1406383299_1976.jpg",
            "http://img.my.csdn.net/uploads/201407/26/1406383291_6518.jpg",
            "http://img.my.csdn.net/uploads/201407/26/1406383291_8239.jpg",
            "http://img.my.csdn.net/uploads/201407/26/1406383290_9329.jpg",
            "http://img.my.csdn.net/uploads/201407/26/1406383290_1042.jpg",
            "http://img.my.csdn.net/uploads/201407/26/1406383275_3977.jpg",
            "http://img.my.csdn.net/uploads/201407/26/1406383265_8550.jpg",
            "http://img.my.csdn.net/uploads/201407/26/1406383264_3954.jpg",
            "http://img.my.csdn.net/uploads/201407/26/1406383264_4787.jpg",
            "http://img.my.csdn.net/uploads/201407/26/1406383264_8243.jpg",
            "http://img.my.csdn.net/uploads/201407/26/1406383248_3693.jpg",
            "http://img.my.csdn.net/uploads/201407/26/1406383243_5120.jpg",
            "http://img.my.csdn.net/uploads/201407/26/1406383242_3127.jpg",
            "http://img.my.csdn.net/uploads/201407/26/1406383242_9576.jpg",
            "http://img.my.csdn.net/uploads/201407/26/1406383242_1721.jpg",
            "http://img.my.csdn.net/uploads/201407/26/1406383219_5806.jpg",
            "http://img.my.csdn.net/uploads/201407/26/1406383214_7794.jpg",
            "http://img.my.csdn.net/uploads/201407/26/1406383213_4418.jpg",
            "http://img.my.csdn.net/uploads/201407/26/1406383213_3557.jpg",
            "http://img.my.csdn.net/uploads/201407/26/1406383210_8779.jpg",
            "http://img.my.csdn.net/uploads/201407/26/1406383172_4577.jpg"
    };
    private ImageView imageView;
    private Handler mUIHandler = new Handler(){
        @Override
        public void handleMessage(Message msg) {
            LogUtils.e("次数:"+msg.what);
            ImageModel model = (ImageModel) msg.obj;
            imageView.setImageBitmap(model.bitmap);
        }
    };
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_handler_thread);
        imageView= (ImageView) findViewById(R.id.image);
        //建立异步HandlerThread
        HandlerThread handlerThread = new HandlerThread("downloadImage");
        //必须先开启线程
        handlerThread.start();
        //子线程Handler
        Handler childHandler = new Handler(handlerThread.getLooper(),new ChildCallback());
        for(int i=0;i<10;i++){
            //每一个1秒去更新图片
            childHandler.sendEmptyMessageDelayed(i,1000*i);
        }
    }
    /**
     * 该callback运行于子线程
     */
    class ChildCallback implements Handler.Callback {
        @Override
        public boolean handleMessage(Message msg) {
            //在子线程中进行网络请求
            Bitmap bitmap=downloadUrlBitmap(url[msg.what]);
            ImageModel imageModel=new ImageModel();
            imageModel.bitmap=bitmap;
            imageModel.url=url[msg.what];
            Message msg1 = new Message();
            msg1.what = msg.what;
            msg1.obj =imageModel;
            //通知主线程去更新UI
            mUIHandler.sendMessage(msg1);
            return false;
        }
    }
    private Bitmap downloadUrlBitmap(String urlString) {
        HttpURLConnection urlConnection = null;
        BufferedInputStream in = null;
        Bitmap bitmap=null;
        try {
            final URL url = new URL(urlString);
            urlConnection = (HttpURLConnection) url.openConnection();
            in = new BufferedInputStream(urlConnection.getInputStream(), 8 * 1024);
            bitmap=BitmapFactory.decodeStream(in);
        } catch (final IOException e) {
            e.printStackTrace();
        } finally {
            if (urlConnection != null) {
                urlConnection.disconnect();
            }
            try {
                if (in != null) {
                    in.close();
                }
            } catch (final IOException e) {
                e.printStackTrace();
            }
        }
        return bitmap;
    }
}
复制代码

思路分析：在这个案例中，咱们建立了两个Handler，一个用于更新UI线程的mUIHandler和一个用于异步下载图片的childHandler。最终的结果是childHandler会每一个隔1秒钟经过sendEmptyMessageDelayed方法去通知ChildCallback的回调函数handleMessage方法去下载图片并告诉mUIHandler去更新UI界面。

HandlerThread源码解析

HandlerThread 源码很是简单，看起来 so easy：

public class HandlerThread extends Thread {
     //优先级
    int mPriority;
    //线程id
    int mTid = -1;
    //线程的looper
    Looper mLooper;

    public HandlerThread(String name) {
        super(name);
        //默认
        mPriority = Process.THREAD_PRIORITY_DEFAULT;
    }

    //也能够指定线程的优先级，注意使用的是 android.os.Process 而不是 java.lang.Thread 的优先级！
    public HandlerThread(String name, int priority) {
        super(name);
        mPriority = priority;
    }

    // 子类须要重写的方法，在这里作一些执行前的初始化工做
    protected void onLooperPrepared() {
    }

    //获取当前线程的 Looper
    //若是线程不是正常运行的就返回 null
    //若是线程启动后，Looper 还没建立，就 wait() 等待 建立 Looper 后 notify
    public Looper getLooper() {
        if (!isAlive()) {
            return null;
        }

        synchronized (this) {
            while (isAlive() && mLooper == null) {    //循环等待
                try {
                    wait();
                } catch (InterruptedException e) {
                }
            }
        }
        return mLooper;
    }

    //调用 start() 后就会执行的 run()
    @Override
    public void run() {
        mTid = Process.myTid();
        //帮咱们建立了 Looepr
        Looper.prepare();  

        synchronized (this) {
           //Looper 已经建立，唤醒阻塞在获取 Looper 的线程
            mLooper = Looper.myLooper();

            notifyAll();    
        }
        Process.setThreadPriority(mPriority);

        //子类可重写的方法
        onLooperPrepared();

        //开始循环
        Looper.loop();  

        //调用quit后才会执行
        mTid = -1;
    }
    //退出
    public boolean quit() {
        Looper looper = getLooper();
        if (looper != null) {
            looper.quit();
            return true;
        }
        return false;
    }
    //安全退出
    public boolean quitSafely() {
        Looper looper = getLooper();
        if (looper != null) {
            looper.quitSafely();
            return true;
        }
        return false;
    }

    public int getThreadId() {
        return mTid;
    }
}
复制代码

能够看到，
①HandlerThread 本质仍是个 Thread，建立后别忘了调用 start()。
②在 run() 方法中建立了 Looper，调用 onLooperPrepared 后开启了循环
③咱们要作的就是在子类中重写 onLooperPrepared，作一些初始化工做
④在建立 HandlerThread 时能够指定优先级，注意这里的参数是 Process.XXX 而不是 Thread.XXX

HandlerThread 的使用场景

咱们知道，HandlerThread 所作的就是在新开的子线程中建立了 Looper，那它的使用场景就是 Thread + Looper 使用场景的结合，即：在子线程中执行耗时的、可能有多个任务的操做。

好比说多个网络请求操做，或者多文件 I/O 等等

参考连接：

  • https://blog.csdn.net/javazejian/article/details/50813444
  • https://blog.csdn.net/u011240877/article/details/72905631
相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程