本文目录
- qt中handler的定义
- 简要描述Handler消息传递机制的步骤
- 如果要对handler发送的消息进行处理，需要重写handler的哪个方法
- ui中handler有什么作用
- handler.post 为什么要将thread对象post到handler中执行
- android中handle在内部类中为什么不执行
qt中handler的定义
Handler的定义:主要接受子线程发送的数据, 并用此数据配合主线程更新UI.解释: 当应用程序启动时，Android首先会开启一个主线程 (也就是UI线程) , 主线程为管理界面中的UI控件，进行事件分发, 比如说, 你要是点击一个 Button ,Android会分发事件到Button上，来响应你的操作。 如果此时需要一个耗时的操作，例如: 联网读取数据， 或者读取本地较大的一个文件的时候，你不能把这些操作放在主线程中，，如果你放在主线程中的话，界面会出现假死现象, 如果5秒钟还没有完成的话，会收到Android系统的一个错误提示 "强制关闭". 这个时候我们需要把这些耗时的操作，放在一个子线程中,因为子线程涉及到UI更新，Android主线程是线程不安全的，也就是说，更新UI只能在主线程中更新，子线程中操作是危险的. 这个时候，Handler就出现了.,来解决这个复杂的问题 , 由于Handler运行在主线程中(UI线程中), 它与子线程可以通过Message对象来传递数据, 这个时候，Handler就承担着接受子线程传过来的(子线程用sedMessage()方法传弟)Message对象，(里面包含数据) , 把这些消息放入主线程队列中，配合主线程进行更新UI。Handler 概念解释：handler类允许你发送消息和处理线程消息队列中的消息及runnable对象。handler实例都是与一个线程和该线程的消息队列一起使用，一旦创建了一个新的handler实例，系统就把该实例与一个线程和该线程的消息队列捆绑起来，这将可以发送消息和runnable对象给该消息队列，并在消息队列出口处处理它们。handler类有两种主要用途：1。按照时间计划，在未来某时刻，对处理一个消息或执行某个runnable实例。2。把一个对另外线程对象的操作请求放入消息队列中，从而避免线程间冲突。时间类消息通过如下方法使用： post(Runnable), postAtTime(Runnable, long), postDelayed(Runnable, long), sendEmptyMessage(int), sendMessage(Message), sendMessageAtTime(Message, long), and sendMessageDelayed(Message, long)methods. post之类函数可以传输一个runnable对象给消息队列，并在到达消息队列后被调用。sendmessage之类函数可以传送一个包含数据的message对象，该message对象可以被Handler类的handleMessage(Message) 方法所处理。post之类函数和sendmessage之类的函数都可以指定消息的执行时机，是立即执行、稍后一段时间执行，还是在某个确定时刻执行。这可以用来实现超时、消息或其他时间相关的操作。当一个进程启动时，主线程独立执行一个消息队列，该队列管理着应用顶层的对象（如：activities、broadcast receivers等等）和所有创建的窗口。你可以创建自己的一个线程，并通过handler来与主线程进行通信。这可以通过在新的线程中调用主线程的handler的post和sendmessage操作来实现。HandlerThread/Looper & MessageQueue & Message的关系：handler 负责将需要传递的信息封装成Message，通过handler 对象的sendMessage()来将消息传递给Looper，由Looper将Message放入MessageQueue中。当Looper对象看到MessageQueue中含有Message，就将其广播出去。该handler 对象收到该消息后，调用相应的handler对象的handleMessage()方法对其进行处理。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 的概念Handler 是用来干什么的？1）执行计划任务，可以在预定的时间执行某些任务，可以模拟定时器
2）线程间通信。在Android的应用启动时，会创建一个主线程，主线程会创建一个消息队列来处理各种消息。当你创建子线程时，你可以在你的子线程中拿到父线程中创建的Handler 对象，就可以通过该对象向父线程的消息队列发送消息了。由于Android要求在UI线程中更新界面，因此，可以通过该方法在其它线程中更新界面。
角色描述：1） Looper: 一个线程可以产生一个Looper对象，由它来管理此线程里的Message Queue
2） Handler: 你可以构造Handler对象来与Looper沟通，以便push 新消息到 Message Queue里，或者接收Looper从Message Queue 里所送来的消息。
3）Message Queue（消息队列）：是用来存放线程放入的消息。
4）线程：UI thread 通常就是 main thread，而Android 启动程序时会替它建立一个Message Queue。
每一个线程里可含有一个 Looper 对象以及一个 Message Queue 数据结构。在你的应用程序里，可以定义 Handler 的子类别来接收 Looper 所送出的消息。
2，Handler 的执行过程
每个handler 对应一个线程 thread , 在子线程中 handler 发送的消息会进入到 Message Queue当中去，由 looper 再来分发给 Handler 处理。
如果要对handler发送的消息进行处理，需要重写handler的哪个方法
Handler类包含如下方法用于发送、处理消息： （1）void handleMessage(Message msg)：处理消息的方法，该方法通常用于被重写。 （2）final boolean hasMessage(int what)：检查消息队列是否包含what属性指定值的消 息。 （3）final boolean hasMessage(int what,Object object)：检查消息队列中是否包含what属 性为指定且object属性为指定指定对象的消息。 （4） Message obtainMessage()：获取消息。（5）sendEmptyMessage(int what)：发送空消息。 （6） final boolean sendEmptyMessageDelayed(int what,long delayMillis)：指定多少毫秒 之后发送空消息。 （7）final boolean sendMessage(Message msg)：立即发送消息。 （8）final boolean sendMessageDelayed(Message msg,long delayMillis)：指定多少毫秒之后发送消息。
ui中handler有什么作用
Handler这个类就是管理某个线程(也可能是进程)的消息队列，比如让Handler处理主线程的消息队列，这样就可以将一些耗时任务放到其他线程之中，待任务完成之后就往主线程的消息队列中添加一个消息，这样Handler的Callback，即handleMessage就会被调用。但是Handler并不是线程安全的，因此官方文档中建议将Handler作为一个静态内部类。所以Handler只是处理消息，耗时任务放在其他线程。Handler的使用主要是android中无法在主线程（即UI线程）中访问网络、无法在子线程中访问UI线程元素。一般是在子线程中访问网络，然后使用Handler发送message通知主线程处理UI更新操作。
handler.post 为什么要将thread对象post到handler中执行
对于线程的控制，我们将介绍一个 Handler类，使用该类可以对运行在不同线程中的多个任务进行排队，并使用Message和Runnable对象安排这些任务。在javadoc中，对Handler是这样解释的：Handler可以发送和处理消息对象或Runnable对象，这些消息对象和Runnable对象与一个线程相关联。每个Handler的实例都关联了一个线程和线程的消息队列。当创建了一个Handler对象时，一个线程或消息队列同时也被创建，该Handler对象将发送和处理这些消息或Runnable对象。 下面有几种对Handler对象的构造方法需要了解一下：a、如果new一个无参构造函数的Handler对象，那么这个Handler将自动与当前运行线程相关联，也就是说这个Handler将与当前运行的线程使用同一个消息队列，并且可以处理该队列中的消息。private Handler handler = new Handler(); 我们做这样一个实验，在主用户界面中创建一个带有无参构造函数的Handler对象，该Handler对象向消息队列推送一个Runnable对象，在Runnable对象的run函数中打印当前线程Id，我们比较主用户界面线程ID和Runnable线程ID是否相同。具体代码如下：public class HandlerTest01 extends Activity {@Overridepublic void onCreate(Bundle savedInstanceState) {super.onCreate(savedInstanceState);setContentView(R.layout.main);System.out.println("Activity ---》 " + Thread.currentThread().getId());handler.post(r);}private Handler handler = new Handler();private Runnable r = new Runnable() {@Overridepublic void run() {try {Thread.sleep(2000);} catch (InterruptedException e) {// TODO Auto-generated catch blocke.printStackTrace();}System.out.println("Runnalbe ---》 " + Thread.currentThread().getId());}};} 通过这个例子的输出可以发现，Runnable对象和主用户界面线程的ID是相同。在这个例子中，我们直接利用handler对象post了一个runnable对象，相当于直接调用了Runnable对象的run函数，也就说没有经过start函数调用run()，那么就不会创建一个新线程，而是在原有线程内部直接调用 run()方法，因此输出的线程Id是相同的。b、如果new一个带参构造函数的Handler对象，那么这个Handler对象将与参数所表示的Looper相关联。注意：此时线程类应该是一个特殊类HandlerThread类，一个Looper类的Thread类，它继承自Thread类。HandlerThread handlerthread = new HandlerThread("MyThread");handlerthread.start();private MyHandler handler = new MyHandler(handlerthread.getLooper());class MyHandler extends Handler {public MyHandler() {}public MyHandler(Looper looper) {super(looper);}} 下面这个例子，将介绍如何开启一个新的线程，并通过Handler处理消息。public class HandlerTest02 extends Activity {private MyHandler myhandler = null;@Overrideprotected void onCreate(Bundle savedInstanceState) {// TODO Auto-generated method stubsuper.onCreate(savedInstanceState);this.setContentView(R.layout.main);System.out.println("Activity ---》 " + Thread.currentThread().getId());// 生成一个HandlerThread对象，使用Looper来处理消息队列HandlerThread thread = new HandlerThread("MyThread");// 必须启动这个线程thread.start();// 将一个线程绑定到Handler对象上，则该Handler对象就可以处理线程的消息队列myhandler = new MyHandler(thread.getLooper());// 从Handler中获取消息对象Message msg = myhandler.obtainMessage();// 将msg对象发送给目标对象Handlermsg.sendToTarget();}class MyHandler extends Handler {public MyHandler() {}// 带有参数的构造函数public MyHandler(Looper looper) {super(looper);}@Overridepublic void handleMessage(Message msg) {System.out.println("MyHandler ---》 " + Thread.currentThread().getId());}}} 根据这个例子返回的结果，可以看出，新线程Id与主用户界面的线程Id不同。由于我们调用了thread.start()方法，真正的创建了一个新线程，与原来的线程处于不同的线程上下文中，因此打印输出的线程Id是不同的。c、如果需要Handler对象去处理消息，那么就要重载Handler类的handleMessage函数。private Handler handler = new Handler() {@Overridepublic void handleMessage(Message msg) {// TODO : Handle the msg// Usually we update UI here.}} 注意到注释部分，我们通常在handleMessage中处理更新UI界面的操作。 前面介绍了Handler类的基本使用，但是还是没有涉及到Thread类。要想实现在后台重新开启一个新的线程，通过该线程执行一些费时的操作，我们也使用Thread类来完成这个功能。下面我们先给出一个使用Thread类的例子程序。public class ThreadTest extends Activity {@Overrideprotected void onCreate(Bundle savedInstanceState) {// TODO Auto-generated method stubsuper.onCreate(savedInstanceState);this.setContentView(R.layout.main);System.out.println("Activity ---》 " + Thread.currentThread().getId());Thread thread = new Thread(r);thread.start();try {Thread.currentThread().sleep(1000);} catch (InterruptedException e) {// TODO Auto-generated catch blocke.printStackTrace();}thread.stop();}Runnable r = new Runnable() {@Overridepublic void run() {System.out.println("Runnable ---》 " + Thread.currentThread().getId());}};} 这个程序执行的结果如下。新线程在创建对象时，传入了Runnable类的一个对象，在Runnable对象中重载了run()方法去执行耗时的操作；新的线程实例执行了start方法，开启了一个新的线程执行Runnable的run方法。上面这些就是我现在接触到执行线程的方法，在线程中，可以完成我们所需要的操作(比如：下载，处理数据，检测网络状态等)，使其与UI界面分离，那么UI界面不会因为耗时操作导致界面被阻塞。 在《解密Google Android》一书中，发现了这样一个启动线程的模型。利用该模型，我们可以把一些耗时的操作放到doStuff方法中去执行，同时在 updateUIHere方法中进行更新UI界面的操作，就可以完成一个线程所需要的功能。其他的说明写在注释部分了。Handler myHandler = new Handler() {public void handleMessage(Message msg) {updateUIHere();}}new Thread() {public void run() {doStuff(); // 执行耗时操作Message msg = myHandler.obtainMessage();Bundle b = new Bundle();b.putString("key", "value");m.setData(b); // 向消息中添加数据myHandler.sendMessage(m); // 向Handler发送消息，更新UI}}.start();======================================================================================================通过上面的文章，可以对handler的处理机制有一个比较深刻的认识，而我之前的疑问，为什么在handler中post一个线程，也就有了答案。handler的应用相当一个对多线程管理的机制，通过一个线程的队列（因为可以post多个）来管理这些线程，同时通过使用Handler或者HandlerThread来控制，这些线程是要在主线程中执行还是要新开一个线程来执行。另外一个不错的例子***隐藏网址***public class HandlerActivity extends Activity { /** Called when the activity is first created. */ @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.main); Button b1 = (Button)findViewById(R.id.button1); Button b2 = (Button)findViewById(R.id.button2); b1.setOnClickListener(new OnClickListener() { @Override public void onClick(View v) { //立即把线程加入消息队列中 handler.post(r); } }); b2.setOnClickListener(new OnClickListener() { @Override public void onClick(View v) { //停止线程 handler.removeCallbacks(r); } }); } Handler handler = new Handler(); /** *该方法的内部类将在handler.sendMessage(msg)后执行 Handler handler = new Handler(){ @Override public void handleMessage(Message msg) { System.out.println("msg:"+msg.arg1); } }; */ Runnable r = new Runnable() { @Override public void run() { System.out.println("sysout Thread"); //得到一个消息对象，Message类是有Android系统 Message msg = handler.obtainMessage(); //将msg对象arg1参数设置为122，用arg1和arg2传递消息 //优点是系统资源消耗较小 msg.arg1 = 122; //将消息加入到另外一个消息队列中去 handler.sendMessage(msg); //3000毫秒后加入线程到消息队列中 handler.postDelayed(r, 3000); } }; }
android中handle在内部类中为什么不执行
当Android应用启动的时候，会先创建一个应用主线程的Looper对象，Looper实现了一个简单的消息队列，一个一个的处理里面的Message对象。主线程Looper对象在整个应用生命周期中存在。当在主线程中初始化Handler时，该Handler和Looper的消息队列关联。发送到消息队列的Message会引用发送该消息的Handler对象，这样系统可以调用 Handler#handleMessage(Message) 来分发处理该消息。在Java中，非静态(匿名)内部类会引用外部类对象。而静态内部类不会引用外部类对象。如果外部类是Activity，则会引起Activity泄露 。当Activity finish后，延时消息会继续存在主线程消息队列中1分钟，然后处理消息。而该消息引用了Activity的Handler对象，然后这个Handler又引用了这个Activity。这些引用对象会保持到该消息被处理完，这样就导致该Activity对象无法被回收，从而导致了上面说的 Activity泄露。要修改该问题，只需要按照Lint提示的那样，把Handler类定义为静态即可，然后通过WeakReference 来保持外部的Activity对象。
