必威体育Betway必威体育官网
当前位置:首页 > IT技术

Handler 使用方法详解

时间:2019-06-18 20:44:16来源:IT技术作者:seo实验室小编阅读:55次「手机版」
 

handler

handler是 Android中用来更新UI 的一套消息处理机制。Handler 允许线程间发送message或Runnable对象进行通信。在Android中UI修改只能通过UI Thread,子线程不能更新UI。如果子线程想更新UI,需要通过 Handler 发送消息给主线程,进而达到更新UI的目的。

欢迎关注微信公众号:程序员Android

公众号ID:ProgramAndroid

获取更多信息

微信公众号:ProgramAndroid

微信公众号:ProgramAndroid

我们不是牛逼的程序员,我们只是程序开发中的垫脚石。

我们不发送红包,我们只是红包的搬运工。

通过本章学习你将掌握以下知识点

  1. Handler 消息处理机制原理
  2. Handler 机制处理的4个关键对象
  3. Handler常用方法
  4. 子线程更新UI 异常处理
  5. 主线程给子线程发送消息的方法
  6. 子线程给主线程发送消息的方法
  7. 主、子 线程 互发消息方法
  8. 子线程方法中调用主线程更新UI的方法

继承关系如下:

java.lang.Object
   ↳    android.os.Handler

1. Handler 消息处理机制原理

当Android 应用程序创建的时候,系统会给每一个进程提供一个Looper ,Looper 是一个死循环,它内部维护一个消息队列,Looper 不停的从消息队列中取Message,取到的消息就发送给handler,最后Handler 根据接收的消息去修改UI等。

2. Handler 机制处理的4个关键对象

1.Message

线程之间传递的消息,可以携带一些简单的数据供子线程与主线程进行交换数据。

2.Message queue

存放通过Handler 发送的 Message 的消息队列,每一个线程只有一个消息队列。

3.Handler

消息处理者,主要用于发送跟处理消息。

主要功能:

发送消息SendMessage()

处理消息 HandleMessage()

4.Looper

内部包含一个死循环的MessageQueue,用于存储handler 发送的Message,Looper则是不断的从消息队列中取消,如果有消息就取出发送给Handler 处理,没有则阻塞。

总结:

Handler 负责发送Message到Message Queue,Looper负责从Message Queue 遍历Message ,然后直接把遍历的消息回传给Handler 自己,通过Handler 自身的handleMessage处理更新UI等操作。

主线程、子线程间通信简单流程

主线程、子线程间通信简单流程

3. Handler常用方法

1.Runnable对象

  • post(Runnable)

使用方法举例:

private Handler mRunnableHandler = new Handler();

    public void RunnableHandlderMethod() {
        new Thread() {
            @Override
            public void run() {
                try {
                    Thread.sleep(1000);
                    mRunnableHandler.post(new Runnable() {
                        @Override
                        public void run() {
                            ((Button) findViewById(R.id.btn_runnable)).setText("Runnable");
                        }
                    });

                } catch (InterruptedException e) {
                    e.printstacktrace();
                }

            }
        }.start();
    }
  • postAtTime(Runnable, long)
  • postDelayed(Runnable, long)
  1. Message 对象

使用方法举例:

private int mCount = 0;
    private Handler mMessageHandler = new Handler() {
        @Override
        public void handleMessage(Message msg) {
            super.handleMessage(msg);

            ((Button) findViewById(R.id.btn_thread)).setText("" + mCount);
        }
    };

    class MessagehandlerthreadMethod extends Thread {
        String mString;
        public MessageHandlerThreadMethod(String str) {
            mString = str;
        }

        @Override
        public void run() {
            for (int i = 0; i < 10; i++) {
                try {
                    Thread.sleep(1000);
                } catch (Exception e) {

                }

                mCount++;
             mMessageHandler.sendEmptyMessage(0);
            }


        }
    }

   //1.Message  对象
        new MessageHandlerThreadMethod("子线程不能更新UI").start();
  • sendMessage(Message),

    使用方法举例:


  • sendMessageAtTime(Message, long),
  • sendMessageDelayed(Message, long)

3.接收、处理Message

  • handleMessage(Message)

使用方法举例:

 private Handler mMessageHandler = new Handler() {
        @Override
        public void handleMessage(Message msg) {
            super.handleMessage(msg);

            ((Button) findViewById(R.id.btn_thread)).setText("" + mCount);
        }
    };

4. 子线程更新UI 异常处理

子线程不能更新UI,如果在子线程中更新UI,会出现CalledFromWrongThreadException 异常。

  • CalledFromWrongThreadException
CalledFromWrongThreadException: 
Only the original thread that created a view hierarchy can touch its views.

解决方法:

子线程通过Handler 发送消息给主线程,让主线程处理消息,进而更新UI。

5. 主线程给子线程发送消息的方法

此例子中子线程通过Looper不断遍历主线程发送的消息,Looper 使用方法如下:

    1. 准备Looper 轮询器

      looper.prepare();

    1. Handler 处理遍历消息

      Handler mHandler = new Handler()

    1. 遍历消息队列

      Looper.loop();

Looper 使用方法如下:

 class LooperThread extends Thread {
      public Handler mHandler;

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

          mHandler = new Handler() {
              public void handleMessage(Message msg) {
                  // process incoming messages here
              }
          };

          Looper.loop();
      }
  }

主线程发送消息的使用例子如下:


    public void BtnMainMessageMethod(View view) {
        Message msg = new Message();
        msg.obj = "主线程:这是我携带的信息";
        if (mMainHandler != null) {
            mMainHandler.sendMessage(msg);
        } else {
            toast.maketext(getAPPlicationcontext(), "开启子线程轮询消息,请再次点击发送消息", Toast.LENGTH_SHORT).show();
            //开启轮询线程,不断等待接收主线成消息
            new ChildLooperThread().start();

        }


    }

    private Handler mMainHandler;
    String mMainMessage;

    // 自定义 Loop 线程 ---> 不停的处理主线程发的消息
    class ChildLooperThread extends Thread {
        @Override
        public void run() {
            // 1.准备成为loop线程
            Looper.prepare();
            // 2.处理消息
            mMainHandler = new Handler() {
                // 处理消息
                public void handleMessage(Message msg) {
                    super.handleMessage(msg);
                    mMainMessage = (String) msg.obj;
                    Log.i("TAG", "子线程:从主线程中接受的消息为:\n" + mMainMessage);
                    // 使用 runOnUiThread  在主线程中更新UI
                    runOnUiThread(new Runnable() {
                        @Override
                        public void run() {
                            ((Button) findViewById(R.id.btn_main_message)).setText(mMainMessage);
                        }
                    });

                }

            };

            // 3.Loop循环方法
            Looper.loop();
        }
    }

6. 子线程给主线程发送消息的方法

子线程发送消息给主线程方法


    public void BtnChildMessageMethod(View view) {

        new Thread() {
            public void run() {

                while (mCount < 100) {
                    mCount++;
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                    /**
                     * 利用handler 对象发送消息
                     *  Message msg=Message.obtain();
                     *   Message msg=new Message(); 获取一个消息对象message
                     * */

                    Message msg = Message.obtain();
                    // 消息标记
                    msg.what = 1;
                    // 传递整型值msg.obj="传递object数据"
                    msg.arg1 = mCount;
                    Log.i("TAG", "count 值=" + mCount);
                    if (mhandler != null) {
                        mhandler.sendMessage(msg);
                    }

                }

            }

            ;
        }.start();
    }

    //定义一个handler 主线程  接收子线程发来的信息
    private Handler mhandler = new Handler() {
        // 處理消息的方法
        public void handleMessage(android.os.Message msg) {

            switch (msg.what) {
                case 1:
                    int value = msg.arg1;
                    Log.i("TAG", "value值=" + value);
                    ((Button) findViewById(R.id.btn_child_message)).setText("当前值=" + value);
                    break;

                default:
                    break;
            }
        }

    };

7. 主、子 线程 互发消息方法

主要实现主、子线程每隔1s中通信一次

  • 实现打印Log如下:

主、子线程通信log信息

主、子线程通信log信息

  • 实现方法如下:

    public void BtnChildMessageMethod(View view) {

        new Thread() {
            public void run() {

                while (mCount < 100) {
                    mCount++;
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                    /**
                     * 利用handler 对象发送消息
                     *  Message msg=Message.obtain();
                     *   Message msg=new Message(); 获取一个消息对象message
                     * */

                    Message msg = Message.obtain();
                    // 消息标记
                    msg.what = 1;
                    // 传递整型值msg.obj="传递object数据"
                    msg.arg1 = mCount;
                    Log.i("TAG", "count 值=" + mCount);
                    if (mhandler != null) {
                        mhandler.sendMessage(msg);
                    }

                }

            }

            ;
        }.start();
    }

    //定义一个handler 主线程  接收子线程发来的信息
    private Handler mhandler = new Handler() {
        // 處理消息的方法
        public void handleMessage(android.os.Message msg) {

            switch (msg.what) {
                case 1:
                    int value = msg.arg1;
                    Log.i("TAG", "value值=" + value);
                    ((Button) findViewById(R.id.btn_child_message)).setText("当前值=" + value);
                    break;

                default:
                    break;
            }
        }

    };

    private Handler mChildHandler;
    //创建主线程
    private Handler mainhandler = new Handler() {
        @Override
        public void handleMessage(Message msg) {
            Log.i("TAG", "子线程对我说:" + msg.obj);

//          主线成携带的消息内容
            Message message = new Message();
            message.obj = Thread.currentThread() + "我是主线程:小子你得听我的。";

//            向子线程发送消息
            mChildHandler.sendMessageDelayed(message, 1000);
        }
    };


    public void BtnMainChildMessageMethod(View view) {

//        创建 名称为currentThread 子线程
        HandlerThread mChildThread = new HandlerThread("ChildThread");
        mChildThread.start();
        mChildHandler = new Handler(mChildThread.getLooper()) {
            @Override
            public void handleMessage(Message msg) {

                Log.i("TAG", "主线程对我说:" + msg.obj);

                // 子线程携带的消息
                Message message = new Message();
                message.obj = Thread.currentThread() + "我是子线程,小样,让我听你的没门";
//                向主线程发送消息
                mainhandler.sendMessageDelayed(message, 1000);
            }
        };
        // 主线成发送空消息,开启通信
        mainhandler.sendEmptyMessage(1);
    }

8.子线程方法中调用主线程更新UI的方法

  • Activity 中 可以使用runOnUiThread(Runnable)
  // 使用 runOnUiThread  在主线程中更新UI
                    runOnUiThread(new Runnable() {
                        @Override
                        public void run() {
                            ((Button) findViewById(R.id.btn_main_message)).setText(mMainMessage);
                        }
                    });
  • Handler.post(Runnable)
  mRunnableHandler.post(new Runnable() {
                        @Override
                        public void run() {
                            ((Button) findViewById(R.id.btn_runnable)).setText("Runnable");
                        }
                    });
  • View.post()
   ((Button) findViewById(R.id.btn_runnable)).post(new Runnable() {
                        @Override
                        public void run() {
                            ((Button) findViewById(R.id.btn_runnable)).setText("Runnable");

                        }
                    });
  • Handler.sendMessage(Message)

至此,本篇已结束,如有不对的地方,欢迎您的建议与指正。同时期待您的关注,感谢您的阅读,谢谢!

如有侵权,请联系小编,小编对此深感抱歉,届时小编会删除文章,立即停止侵权行为,请您多多包涵。

既然都看到这里,领两个红包在走吧!

以下两个红包每天都可以领取

1.支付宝搜索 522398497,或扫码支付宝红包海报。

支付宝扫一扫,每天领取大红包

2.微信红包,微信扫一扫即可领取红包

微信扫一扫,每天领取微信红包

小礼物走一走,来简书关注我

相关阅读

Handler还需要用到弱引用(WeakReference)吗?

转自:https://blog.csdn.net/alcoholdi/article/details/54948058  写的很好网上很多文章都说写Hanlder,需要用static声明为静态的

Message.obtain() 和Handler.obtainMessage()的区别

Message.obtain() 和Handler.obtainMessage()的区别 性能更优越 尽管Message的构造器是公开的,但是获取Message对象的最好

Android HandlerThread使用介绍以及源码解析

1. 前言 首先,看一下官方对HandlerThread的解释: Handy class for starting a new thread that has a looper. The looper can th

C# EventHandler委托事件小结

最近遇到一个委托的问题,+=这个符号,哇,真的是头皮发麻,以为是运算符,根本不知道是委托 -。-!! 看下图: 后面查了以后原来这种用法真的很

Handler的作用与用法

1.什么是handler? Handler是Android SDK来处理异步消息的核心类。 子线程与主线程通过Handler来进行通信。子线程可以通过Handle

分享到:

栏目导航

推荐阅读

热门阅读