一、Handler的定义:
          主要接受子线程发送的数据,并用此数据配合主线程更新UI.
          解释:当应用程序启动时，Android首先会开启一个主线程 (也就是UI线程) , 主线程为管理界面中的UI控件，进行事件分发,比如说, 你要是点击一个 Button, Android会分发事件到Button上，来响应你的操作。  如果此时需要一个耗时的操作，例如:联网读取数据，或者读取本地较大的一个文件的时候，你不能把这些操作放在主线程中，如果你放在主线程中的话，界面会出现假死现象,如果5秒钟还没有完成的话，会收到Android系统的一个错误提示  "强制关闭".  这个时候我们需要把这些耗时的操作，放在一个子线程中,因为子线程涉及到UI更新，Android主线程是线程不安全的，也就是说，更新UI只能在主线程中更新，子线程中操作是危险的.这个时候，Handler就出现了来解决这个复杂的问题，由于Handler运行在主线程中(UI线程中)，它与子线程可以通过Message对象来传递数据，这个时候，Handler就承担着接受子线程传过来的(子线程用sedMessage()方法传弟)Message对象，(里面包含数据)  ,把这些消息放入主线程队列中，配合主线程进行更新UI。

二、Handler一些特点
        handler可以分发Message对象和Runnable对象到主线程中,每个Handler实例,都会绑定到创建他的线程中(一般是位于主线程),
        它有两个作用: (1):  安排消息或Runnable在某个主线程中某个地方执行, (2)安排一个动作在不同的线程中执行
      
        Handler中分发消息的一些方法
        post(Runnable)
        postAtTime(Runnable,long)
        postDelayed(Runnable long)
        sendEmptyMessage(int)
        sendMessage(Message)
        sendMessageAtTime(Message,long)
        sendMessageDelayed(Message,long)
        以上post类方法允许你排列一个Runnable对象到主线程队列中,
        sendMessage类方法,允许你安排一个带数据的Message对象到队列中，等待更新.

三、Handler实例
      (1) 子类需要继承Handler类，并重写handleMessage(Message msg)方法, 用于接受线程数据
      以下为一个实例，它实现的功能为 :通过线程修改界面Button的内容

public class MyHandlerActivity extendsActivity {

Button button;

MyHandler myHandler;

protected void onCreate(Bundle savedInstanceState) {

super.onCreate(savedInstanceState);

setContentView(R.layout.handlertest);

button = (Button) findViewById(R.id.button);

myHandler = new MyHandler();

// 当创建一个新的Handler实例时, 它会绑定到当前线程和消息的队列中,开始分发数据

// Handler有两个作用, (1) : 定时执行Message和Runnalbe 对象

// (2): 让一个动作,在不同的线程中执行.

// 它安排消息,用以下方法

// post(Runnable)

// postAtTime(Runnable,long)

// postDelayed(Runnable,long)

// sendEmptyMessage(int)

// sendMessage(Message);

// sendMessageAtTime(Message,long)

// sendMessageDelayed(Message,long)

// 以上方法以 post开头的允许你处理Runnable对象

//sendMessage()允许你处理Message对象(Message里可以包含数据,)

MyThread m = new MyThread();

new Thread(m).start();

}

/**

* 接受消息,处理消息 ,此Handler会与当前主线程一块运行

* */

class MyHandler extends Handler {

public MyHandler() {

}

public MyHandler(Looper L) {

super(L);

}

// 子类必须重写此方法,接受数据

@Override

public void handleMessage(Message msg) {

// TODO Auto-generated method stub

Log.d("MyHandler", "handleMessage......");

super.handleMessage(msg);

// 此处可以更新UI

Bundle b = msg.getData();

String color = b.getString("color");

MyHandlerActivity.this.button.append(color);

}

}

class MyThread implements Runnable {

public void run() {

try {

Thread.sleep(10000);

} catch (InterruptedException e) {

// TODO Auto-generated catchblock

e.printStackTrace();

}

Log.d("thread.......", "mThread........");

Message msg = new Message();

Bundle b = new Bundle();// 存放数据

b.putString("color", "我的");

msg.setData(b);

MyHandlerActivity.this.myHandler.sendMessage(msg); // 向Handler发送消息,更新UI

}

}

1. 传递Message。用于接受子线程发送的数据, 并用此数据配合主线程更新UI。

在Android中，对于UI的操作通常需要放在主线程中进行操作。如果在子线程中有关于UI的操作，那么就需要把数据消息作为一个Message对象发送到消息队列中，然后，有Handler中的handlerMessge方法处理传过来的数据信息，并操作UI。当然，Handler对象是在主线程中初始化的，以为它需要绑定在主线程的消息队列中。

类sendMessage(Message msg)方法实现发送消息的操作。 在初始化Handler对象时重写的handleMessage方法来接收Messgae并进行相关操作。

1.  //Handler处理子线程消息代码示例：

2.

3.  public class Activity01 extends Activity

4.  {

5.      //声明ProgressBar对象

6.      private ProgressBar m_ProgressBar;

7.      private ProgressBar m_ProgressBar2;

8.      private Button mButton01;

9.      protected static final int GUI_STOP_NOTIFIER = 0x108;

10.    protected static final int GUI_THREADING_NOTIFIER = 0x109;

11.    public int intCounter=0;

12.    /** Called when the activity is first created. */

13.    @Override

14.    public void onCreate(Bundle savedInstanceState)

15.    {

16.        super.onCreate(savedInstanceState);

17.        //设置窗口模式，，因为需要显示进度条在标题栏

18.        requestWindowFeature(Window.FEATURE_PROGRESS);

19.        setProgressBarVisibility(true);

20.        setContentView(R.layout.main);

21.

22.        //取得ProgressBar

23.        m_ProgressBar = (ProgressBar) findViewById(R.id.ProgressBar01);

24.        m_ProgressBar2= (ProgressBar) findViewById(R.id.ProgressBar02);

25.        mButton01 = (Button)findViewById(R.id.Button01);

26.

27.        m_ProgressBar.setIndeterminate(false);

28.        m_ProgressBar2.setIndeterminate(false);

29.

30.        //当按钮按下时开始执行,

31.        mButton01.setOnClickListener(new Button.OnClickListener()

32.        {

33.          @Override

34.          public void onClick(View v)

35.          {

36.            // TODO Auto-generated method stub

37.

38.              //设置ProgressBar为可见状态

39.              m_ProgressBar.setVisibility(View.VISIBLE);

40.              m_ProgressBar2.setVisibility(View.VISIBLE);

41.              //设置ProgressBar的最大值

42.              m_ProgressBar.setMax(100);

43.              //设置ProgressBar当前值

44.              m_ProgressBar.setProgress(0);

45.              m_ProgressBar2.setProgress(0);

46.

47.              //通过线程来改变ProgressBar的值

48.  new Thread(new Runnable() {

49.     public void run()

50.        {

51.     for (int i = 0; i < 10; i++)

52.        {

53.           try

54.           {

55.                 intCounter = (i + 1) * 20;

56.                 Thread.sleep(1000);

57.

58.            if (i == 4)

59.            {

60.            Message m = new Message();

61.

62.             m.what = Activity01.GUI_STOP_NOTIFIER;

63.            Activity01.this.myMessageHandler.sendMessage(m);

64.  //将message发送到消息队列

65.              break;

66.             }

67.            else

68.           {

69.           Message m = new Message();

70.           m.what = Activity01.GUI_THREADING_NOTIFIER;

71.           Activity01.this.myMessageHandler.sendMessage(m);

72. //将message发送到消息队列

73.                                }

74.                            }

75.                            catch (Exception e)

76.                            {

77.                                e.printStackTrace();

78.                            }

79.                        }

80.                    }

81.                }).start();

82.            }

83.        });

84.    }

85.

86.//通过匿名类复写Handler类中的handleMessage方法，用于接收传递到消息队列中的Message，并进行UI操作。

87.      Handler myMessageHandler = new Handler()

88.      {

89.        // @Override

90.          public void handleMessage(Message msg)

91.          {

92.              switch (msg.what)

93.              {

94.              //ProgressBar已经是对大值

95.              case Activity01.GUI_STOP_NOTIFIER:

96.                  m_ProgressBar.setVisibility(View.GONE);

97.                  m_ProgressBar2.setVisibility(View.GONE);

98.                  Thread.currentThread().interrupt();

99.                  break;

100.               case Activity01.GUI_THREADING_NOTIFIER:

101.                   if (!Thread.currentThread().isInterrupted())

102.                   {

103.                       // 改变ProgressBar的当前值

104.                       m_ProgressBar.setProgress(intCounter);

105.                       m_ProgressBar2.setProgress(intCounter);

106.

107.                       // 设置标题栏中前景的一个进度条进度值

108.                       setProgress(intCounter*100);

109.                       // 设置标题栏中后面的一个进度条进度值

110.                       setSecondaryProgress(intCounter*100);//

111.                   }

112.                   break;

113.               }

114.               super.handleMessage(msg);

115.          }

116.       };

117. }

以上的例子中，子线程只是对进度条的参数进行了变更，并将结果以message形式发送到消息队列中去，子线程的内部并未进行UI操作，而是在重写的Handler的handlerMessage方法中操作了UI界面。

2.传递Runnable对象。用于通过Handler绑定的消息队列，安排不同操作的执行顺序。

Handler对象在进行初始化的时候，会默认的自动绑定消息队列。利用类post方法，可以将Runnable对象发送到消息队列中，按照队列的机制按顺序执行不同的Runnable对象中的run方法。

1.  public class HandlerActivity extends Activity {

2.      /** Called when the activity is first created. */

3.      //声明两个按钮控件

4.      private Button startButton = null;

5.      private Button endButton = null;

6.      @Override

7.      public void onCreate(Bundle savedInstanceState) {

8.          super.onCreate(savedInstanceState);

9.          setContentView(R.layout.main);

10.        //根据控件的ID得到代表控件的对象，并未这两个按钮设置相应的监听器

11.        startButton = (Button)findViewById(R.id.startButton);

12.        startButton.setOnClickListener(new StartButtonListener());

13.        endButton = (Button)findViewById(R.id.endButton);

14.        endButton.setOnClickListener(new EndButtonListener());

15.

16.    }

17.    class StartButtonListener implements OnClickListener{

18.

19.        @Override

20.        public void onClick(View v) {

21.            //调用Handler的post方法，将要执行的线程对象添加到队列当中

22.            handler.post(updateThread);

23.        }

24.

25.    }

26.

27.    class EndButtonListener implements OnClickListener{

28.

29.        @Override

30.        public void onClick(View v) {

31.            handler.removeCallbacks(updateThread);

32.        }

33.

34.    }

35.    //创建一个Handler对象

36.    Handler handler  = new Handler();

37.    //将要执行的操作写在线程对象的run方法当中

38.    Runnable updateThread =  new Runnable(){

39.

40.        @Override

41.        public void run() {

42.            System.out.println("UpdateThread");

43.            //在run方法内部，执行postDelayed或者是post方法

44.            handler.postDelayed(updateThread, 3000);

45.        }

46.

47.    };

48.}

程序的运行结果就是每隔3秒钟，就会在控制台打印一行UpdateTread。这是因为实现了Runnable接口的updateThread对象进入了空的消息队列即被立即执行run方法，而在run方法的内部，又在3000ms之后将其再次发送进入消息队列中。

3. Handler和多线程

post方法虽然发送的是一个实现了Runnable接口的类对象，但是它并非创建了一个新线程，而是执行了该对象中的run方法。也就是说，整个run中的操作和主线程处于同一个线程。

这样对于那些简单的操作，似乎并不会影响。但是对于耗时较长的操作，当它被加入到消息队列中之后执行会占用很长的时间，以至于处于同一线程的其他操作无法继续执行，就会出现“假死”。为了解决这个问题，就需要使得handler绑定到一个新开启线程的消息队列上，在这个处于另外线程的上的消息队列中处理传过来的Runnable对象和消息。SDK文档中也提供了相关说明：

When a process is created for your application, its main thread is dedicated to running a message queue that takes care of managing the top-level application objects (activities, broadcast receivers, etc) and any windows they create. You can create your own threads, and communicate back with the main application thread through a Handler. This is done by calling the samepost or sendMessage methods as before, but from your new thread. The given Runnable or Message will than be scheduled in the Handler's message queue and processed when appropriate.

具体操作方法如下：

1.  public class HandlerTest2 extends Activity {

2.

3.      @Override

4.      protected void onCreate(Bundle savedInstanceState) {

5.          // TODO Auto-generated method stub

6.      super.onCreate(savedInstanceState);

7.      setContentView(R.layout.main);

8.      //打印了当前线程的ID

9.      System.out.println("Activity-->" + Thread.currentThread().getId());

10.    //生成一个HandlerThread对象

11.    HandlerThread handlerThread = new HandlerThread("handler_thread");

12.    //在使用HandlerThread的getLooper()方法之前，必须先调用该类的start()，同时开启一个新线程;

13.    handlerThread.start();

14.   //将由HandlerThread获取的Looper传递给Handler对象，即由处于另外线程的Looper代替handler初始化时默认绑定的消息队列来处理消息。

15.    MyHandler myHandler = new MyHandler(handlerThread.getLooper());

16.    Message msg = myHandler.obtainMessage();

17.    //将msg发送到目标对象，所谓的目标对象，就是生成该msg对象的handler对象

18.    Bundle b = new Bundle();

19.    b.putInt("age", 20);

20.    b.putString("name", "Jhon");

21.    msg.setData(b);

22.    msg.sendToTarget();  //将msg发送到myHandler

23.    }

24.

25.   //定义类

26.    class MyHandler extends Handler{

27.    public MyHandler(){

28.

29.    }

30.

31.    public MyHandler(Looper looper){

32.        super(looper);

33.    }

34.    @Override

35.    public void handleMessage(Message msg) {

36.        Bundle b = msg.getData();

37.        int age = b.getInt("age");

38.        String name = b.getString("name");

39.        System.out.println("age is " + age + ", name is" + name);

40.        System.out.println("Handler--->" + Thread.currentThread().getId());

41.        System.out.println("handlerMessage");

42.        }

43.    }

44.}

这样，当使用sendMessage方法传递消息或者使用post方法传递Runnable对象时，就会把它们传递到与handler对象绑定的处于另外一个线程的消息队列中，它们将在另外的消息队列中被处理。而主线程还会在发送操作完成时候继续进行，不会影响当前的操作。

这里需要注意，这里用到的多线程并非由Runnable对象开启的，而是ThreadHandler对象开启的。Runnable对象只是作为一个封装了操作的对象被传递，并未产生新线程。

androidHandler讲解相关推荐

  1. 从命令行到IDE，版本管理工具Git详解（远程仓库创建+命令行讲解+IDEA集成使用）

    首先,Git已经并不只是GitHub,而是所有基于Git的平台,只要在你的电脑上面下载了Git,你就可以通过Git去管理"基于Git的平台"上的代码,常用的平台有GitHub.Gi ...

  2. 详细通俗重点CRF层讲解

    本文翻译自GitHub博客上的原创文章,结尾有原文链接.文章没有晦涩的数学公式,而是通过实例一步一步讲解CRF的实现过程,是入门CRF非常非常合适的资料. 相关项目代码: BERT-BiLSMT-CR ...

  3. 高级数据结构讲解与案例分析

    然而,仅仅掌握好它们不足以应付大厂的算法面试的.为了达到对时间和空间复杂度的理想要求,本节课探究高级数据结构,它们的实现要比那些常用的数据结构要复杂得多.其中重点介绍: 优先队列 图 前缀树 线段树 ...

  4. php 伪静态 page-18.html,PHP 伪静态实现技术原理讲解

    PHP 伪静态实现技术原理讲解 发布于 2015-01-18 23:52:58 | 129 次阅读 | 评论: 0 | 来源: 网友投递 PHP开源脚本语言PHP(外文名: Hypertext Pre ...

  5. ssm开发框架原理_SSM 单体框架 - 前端开发：视频讲解

    视频讲解 知乎视频​www.zhihu.com 知乎视频​www.zhihu.com 知乎视频​www.zhihu.com 知乎视频​www.zhihu.com 知乎视频​www.zhihu.com ...

  6. python计算wav的语谱图_Python实现电脑录音（含音频基础知识讲解）

    前言 今天开始进入近期系列文章的第一篇,如何用 Python 来实现录音功能. 在开始"造轮子"之前,个人一直强调一个观点,如果有些东西已经有了,不妨直接去 github 上搜,用 ...

  7. PCL：k-d tree 1 讲解

    1.简介 kd-tree简称k维树,是一种空间划分的数据结构.常被用于高维空间中的搜索,比如范围搜索和最近邻搜索.kd-tree是二进制空间划分树的一种特殊情况.(在激光雷达SLAM中,一般使用的是三 ...

  8. 基础矩阵，本质矩阵，单应性矩阵讲解

    ORB-SLAM点云地图中相机的位姿初始化,无论算法工作在平面场景,还是非平面场景下,都能够完成初始化的工作.其中主要是使用了适用于平面场景的单应性矩阵H和适用于非平面场景的基础矩阵F,程序中通过一个 ...

  9. 藤摇椅游戏道具制作全流程讲解视频教程

    藤摇杆|一个完整的游戏资产工作流程 MP4 |视频:h264,1280×720 |音频:AAC,44.1 KHz,2 Ch 含工程素材 语言:英语+中文字幕(根据原英文字幕机译更准确)+原英文字幕 | ...

最新文章

  1. MySQL高性能优化规范建议
  2. no Bloomberg, wind, ceic, csmar at cambridge
  3. 55_pytorch,自定义数据集
  4. JDK8那些惊为天人的新特性
  5. href=“javascript:void(0);”和href=void(change_code(this));
  6. 基于Berkeley DB实现的持久化队列
  7. 熊言乱语 | 第33届浙江省青少年科技创新大赛获奖作品赏析
  8. Java学习笔记——判断一个数是否是质数
  9. 奔梦向前-代码实现表白男生女生-2020-06-15
  10. 微信小程序自动注册获取token
  11. mymps蚂蚁分类信息模板二次开发调用标签
  12. Java编程思想之对象入门
  13. artifactIdsolace-spring-boot-starter/artifactId
  14. python自动定期清理日志脚本支持Linux+windows
  15. 中小企业数字化转型难，不妨先从业务流程自动化开始
  16. idea断点调试，调试结束后，下次无法进入断点
  17. 2019奥林匹克计算机竞赛试题,2019-2020年小学数学奥林匹克竞赛试题及答案三年级...
  18. 阿里巴巴2017实习生招聘研发工程师JAVA考试 最懵逼的逻辑题
  19. ChIP-seq 分析：基因集富集（11）
  20. 2020-11-17最小转弯半径计算

热门文章

  1. 项目启动 ora-00942:_如何解决大型软件项目开发难题？唯快不破！
  2. 电脑只有一个c盘怎么办_电脑的C盘快满了怎么办
  3. mysql pdo 获取最后一条sql_一条SQL如何在MYSQL中执行的
  4. containerd和docker技术的比较
  5. python使用redis队列_Python的Flask框架应用调用Redis队列数据的方法
  6. eplan增加其他到工具栏_EPLAN增效之工具栏定制(十三:端子排编辑不进导航器)
  7. 僵尸进程的产生与处理
  8. java selenium后报错Element not found in the cache元素定位要重新赋值之前的定义
  9. .NET出现频率非常高的笔试题
  10. 搜索引擎爬虫蜘蛛的UserAgent收集