handler

当使用枚举时，需要使用EnumTypeHandler或者EnumOrdinalTypeHandler作为映射类型，或者自己实现处理器。EnumOrdinalTypeHandler只能处理特定的类型，当我们需要使用真正意义上的枚举，需要使用EnumTypeHandler或者自己实现。

Request handlers: Each service has its own request handler.请求处理程序：每个服务都有自己的请求处理程序。

android 中的HandlerThread包含了android中的消息处理机制必须的looper，当你启动这个线程的时候，就会闯进looper，并开启消息处理的循环。跟其它线程一样，HandlerThread是可不可以直接stop掉的，不过经过本人测试，你可以调用：getLooper().quit();来退出这个线程，其实原理很简单，就是改变在消息循环里面标志位，退出整个while循环，使线程执行完毕。 部分 测试代码如下：public void onCreate(Bundle savedInstanceState) {super.onCreate(savedInstanceState);setContentView(R.layout.main);tv_name = (TextView) findViewById(R.id.tv_name);btn_name = (Button) findViewById(R.id.btn_name);Log.i(TAG, "==================main thread:" + Thread.currentThread().getName());final HandlerThread thread = new HandlerThread("handlerThread");thread.start();final MyHandler handler = new MyHandler(thread.getLooper());btn_name.setOnClickListener(new OnClickListener() {@Overridepublic void onClick(View v) {handler.sendEmptyMessage(1);try {Thread.sleep(3000);} catch (InterruptedException e) {e.printStackTrace();}thread.getLooper().quit();}});}class MyHandler extends Handler {public MyHandler(Looper looper) {super(looper);}@Overridepublic void handleMessage(Message msg) {Log.i(TAG, "==================" + Thread.currentThread().getName());//tv_name.setText("hello, this is the first message from handler");不过要注意：要想更新界面内容，还是需要使用界面的Looper，不然的话还是会抛错误，还是那句话，所有跟改变界关的操作，都得通过界面的Looper来执行

子线程中不能用操作主线程，你looper准备后还需要在队列最后调用looper.loop()才行，最好的方法是你new handler的时候给handler的参数用looper.getMainlooper()就好了

把handleMessage 放到 run里试试new Handler(@Overridepublic boolean handleMessage(Message mGRCMessage) {//...}}

Android Handler机制 - MessageQueue如何处理消息 Handler 如何做到阻塞 Android篇：2019初中级Android开发社招面试解答（中） Handler消息机制组成： 如何保证looper的唯一性 每个线程只有一个looper，而每个Thread中都又一个关键Threadlocal。是用于存放每个线程的looper对象的，存取的方式是通过get/set。相当于一个map的存放方式。键位key是当前线程的实例。value就是looper对象。所以每次创建looper都会去ThreadLocal里面找有没有当前线程的looper。 如何知道 message 发送到哪个handler处理 当使用 Handler.sendMessage() 发送消息时，调用 enqueueMessage 方法内有 msg.target = this 将 Handler 实例赋值给 msg 对象。当 loop() 取出消息时，调用 dispatchMessage 方法根据 target 属性，回调对应 handler 实例的 handlerMessage 方法处理消息。 调用nativeWake唤醒(这部分内容出自头部连接，详细源码分析可看前辈的) 既然有写入消息，那必定要把消息处理掉，所以唤醒了epoll_wait()，然后继续方法调动awoken(),这个方法就是将之前写入的1读出，表示消费这个事件 随后在Java 层的next()@MessageQueue 就被唤醒，读取在enqueueMessage()@MessageQueue 插在队头的消息进行处理

InvalidateEventHandler委托创建InvalidateEventHandler委托时，标识将处理事件的方法。若要使该事件与事件处理程序相关联，请将该委托的一个实例添加到事件中。除非移除了该委托，否则每当发生该事件时就调用事件处理程序。有关用委托处理事件的更多信息给分~

<%@ WebHandler language="C#" Class="HandlerExample.TextBuilder" codebehind="TextBuilder.ashx.cs"%> Class="HandlerExample.TextBuilder"换成Class="HandlerExample.MyHttpHandler"；或者这样写<%@ WebHandler language="C#" Class="TextBuilder"%>

TypeHandler写起来很容易，但是有一个很重要的点需要注意。你是否遇到过类似下面的错误：Caused by: java.lang.RuntimeException: 调用方法异常:java.lang.IllegalStateException: Type handler was null on parameter mapping for property "xxx". It was either not specified and/or could not be found for the javaType / jdbcType combination specified.1如果你遇到了这个问题，那么这篇博客正好适合你。如果你还没遇到，也可以避免遇到这个问题。先说错误的原因，MyBatis在查找类型的TypeHandler的时候，调用下面的方法：private <T> TypeHandler<T> getTypeHandler(Type type, JdbcType jdbcType) { Map<JdbcType, TypeHandler<?>> jdbcHandlerMap = TYPE_HANDLER_MAP.get(type); TypeHandler<?> handler = null; if (jdbcHandlerMap != null) { handler = jdbcHandlerMap.get(jdbcType); if (handler == null) { handler = jdbcHandlerMap.get(null); } } if (handler == null && type != null && type instanceof Class && Enum.class.isAssignableFrom((Class<?>) type)) { handler = new EnumTypeHandler((Class<?>) type); } // type drives generics here return (TypeHandler<T>) handler;}1234567891011121314151617一般情况下我们如果在Mapper.xml中使用的resultType，或者使用的resultMap但是resultMap的配置中没有指定特殊类型字段的jdbcType，就会出现上面的错误。从上面源码很容易能看出来，当jdbcType是null的时候：handler = jdbcHandlerMap.get(jdbcType);if (handler == null) { handler = jdbcHandlerMap.get(null);}1234jdbcHandlerMap.get(jdbcType)和jdbcHandlerMap.get(null)作用是一样的，结果都是null,因此就会报出上面提到的错误。这个错误如何解决呢？如果仅从上面错误的原因配置一个jdbcType也解决不了使用resultType时的问题。从源码handler = jdbcHandlerMap.get(null);这里可以看到，默认情况下如果有jdbcType，但是handler=null，也会尝试取出一个key为null的handler。也就是说一般情况下，我们自己配置的TypeHandler都需要有一个key=null的键值。如何设置一个null的key呢？如果你认为是枚举类型JdbcType.NULL那就错了。TypeHandler有两种设置null的方式：1. @MappedJdbcTypes注解@Retention(RetentionPolicy.RUNTIME)@Target(ElementType.TYPE)public @interface MappedJdbcTypes { public JdbcType[] value(); boolean includeNullJdbcType() default false;}123456该注解包含一个属性includeNullJdbcType，将该属性设置为true即可。2. xml配置首先重点说明一下:如果使用了上面的注解配置，那么在xml中的jdbcType配置不会起作用，会完全使用注解中的配置。xml配置方法很简单，那就是不要配置jdbcType属性，例如：<!-- mybatis-config.xml --><typeHandlers> <typeHandler handler="org.mybatis.example.ExampleTypeHandler"/></typeHandlers>1234这种情况下就配置了一个只有null的jdbcType。实际上大多数人可能都是这么配置的，因此都没有遇到过这个异常。

看下是不是该文件的扩展名变了，如果真是变了就把它的扩展名改成跟以前一样看下行不行！如果你找不到这个程序了，并且你权限卸载这个程序可考虑下把它卸了后再安装下，但如果你不想这样做的话，或者你知道这个程序当时安装的时候你记得安装在C盘的哪个位置的话，找到它，将那shellscrapobjecthandler程序的快捷图标快捷到桌面，把你的那个片段拉到那个程序里面试试，我想shellscrapobjecthandler是个播放器吧！首先你要保证你的片段没有损坏，你是从PPT里把这个片段拉出来的吧，我还从没这样做，可以试下在PPT里复制这个片段，然后粘贴到桌面，还有选中这个片段可不可以另存为，好久没做PPT了，都忘了！希望能对你有所帮助！

是指导的意思吗

Handler在Android中负责调度消息并将来某个时段处理消息。Android有大量的消息驱动方式来进行交互，比如四大组件的的启动过程的交互，都离不开消息机制。 消息机制涉及MessageQueue/Message/Looper/Handler这4个类。 Message：消息分为硬件产生的消息(如按钮、触摸)和软件生成的消息； MessageQueue：消息队列的主要功能向消息池投递消息和取走消息池的消息； Handler：消息辅助类，主要功能向消息池发送各种消息事件(Handler.sendMessage)和处理相应消息事件(Handler.handleMessage)； Looper：不断循环执行(Looper.loop)，按分发机制将消息分发给目标处理者。 这里是通过Looper中的myLooper方法来获得Looper实例的，如果Looper为null的话就会抛异常，抛出的异常内容翻译过来就是无法在未调用 Looper.prepare（）的线程内创建handler，new handler的时候没有报错那么就一定之前就调用了 Looper.Prepare（），在哪里创建的呢？ 答案在 ActivityThread.main() 中。 ActivityThread 的 main（）方法就是整个APP的入口，也就是我们通常所讲的主线程， UI线程。但他实际上并不是一个线程，ActivityThread 并没有继承 Thread 类，我们可以把他理解为主线程的管理者，负责管理主线程的执行，调度等操作，看下main方法的源码。 两个关键方法 Looper.prepareMainLooper()和Looper.loop()，loop方法后面再分析，继续看prepareMainLooper的方法内部如下： 到1u20e3ufe0f这里就解决了，为什么我们在主线程中使用Handler之前没有调用Looper.prepare方法的问题了，就是在这里调用了prepare 方法。 2u20e3ufe0fprepare方法内部把 Looper 放到ThreadLocal中与当前线程绑定，保证一个线程只有一个Looper实例，同时一个Looper实例也只有一个MessageQueue。 3u20e3ufe0f在Looper的构造函数中始化MessageQueue 所以初始化Handler之前Looper 和 MessageQueue就已经初始化了,并把Looper放到ThreadLocal中。ThreadLocal有个特点是你set进去的值是以当前所处的线程为key，value就是你set的值。源码如下： 先看一下sendMessage的流程图： 简单过一遍，sendXXX 这些方式最终还是会调用到 enqueueMessage 这个方法上来的逻辑最后调用queue.enqueueMessage 添加消息到消息队列MessageQueue中，下面就是消息的入队逻辑 消息入队顺序是按照 Message 触发时间 long when入队的，有新消息加入时，会循环遍历当前消息队列，对比消息触发时间，直到找到当前消息合适的插入位置，以此来保证所有消息的触发时间顺序。即 MessageQueue 添加消息到消息队列中。 Handler把Message交给MessageQueue并存储起来 ，那么谁来负责把我这里的消息分发出去并且告诉主线程的人（Handler）呢？答案就是 Looper 了！ 之前分析的ActivityThread.main()中的Looper.loop还没有讲到我们接着跟进去看一下源码 loop()不断从MessageQueue中取消息，把消息交给target（handler）的dispatchMessage方法处理。下面是dispatchMessage 可以看到dispatchMessage最后调用了handleMessage方法，在源码里面是个空实现。需要我们在创建handler的时候复写，根据不同的message处理不同的业务逻辑。 整个Handler的消息分发调度流程就讲完了，为了增强记忆，我再把整个流程拼成一块如下图：

此方法会在工作线程执行的

import logging # 1、创建一个logger logger = logging.getLogger("mylogger") logger.setLevel(logging.DEBUG) # 2、创建一个handler，用于写入日志文件 fh = logging.FileHandler("test.log") fh.setLevel(logging.DEBUG) # 再创建一个handler，用于输出到控制台 ch = logging.StreamHandler() ch.setLevel(logging.DEBUG) # 3、定义handler的输出格式（formatter）formatter = logging.Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s") # 4、给handler添加formatterfh.setFormatter(formatter) ch.setFormatter(formatter) # 5、给logger添加handler logger.addHandler(fh) logger.addHandler(ch)

转塔式handler是一种用于自动化芯片测试的设备。它通常由一个旋转的塔体和一个或多个芯片夹具组成。在测试过程中，芯片夹具会把芯片固定在测试位置，而塔体则会旋转，使芯片夹具能够接触到测试设备上的测试点。转塔式handler的芯片定位方式可以采用两种方法：机械定位和光学定位。机械定位：这种方法是通过芯片夹具上的机械夹具来实现芯片定位的。机械夹具通常是由几个齿形组成的，可以把芯片固定在测试位置上。光学定位：这种方法是通过光学传感器来实现芯片定位的。光学传感器可以通过检测芯片上的特定标记，来确定芯片在测试位置上的位置信息。转塔式handler的芯片定位方式可以根据芯片的尺寸、形状和测试要求选择不同的方法。一般来说，光学定位方式比机械定位方式更精确，但是也更复杂、成本更高。

首先，Handler的post方法不会在每次使用时都创建一个子线程，post方法的源码如下。因而post每次都是通过传入的Runnable对象获取信息再返回，而不是重新创建线程。post方法通常是通知更新UI界面组件，sendMessage()起到通知Handler执行指定更新操作

你这个不必那么纠结 比如 你在全局设置一个isStart的 默认是false 第一次启动变成true 这样不就可以了

没有所谓好不好，在其他线程更新UI最终还是转变为在UI线程里更新，因为UI线程是主线程，其他线程想直接操作UI是不行的，可以借助Handlerandmessage机制。如果你的功能逻辑复杂度较高，就是说运行时间较长，那么最好是另开一个线程做逻辑处理，

数据存储问题。如果数据没有正确保存在持久存储的文件夹中，而是保存在内存中或临时存储中，那么当应用程序更新或重新启动时，数据将丢失。handler中更新的数据能够长期保留，需要确保将数据存储在合适的位置，如数据库或者文件中。确保在更新数据后，将其正确保存，并在需要时从存储中读取。

指定Activity创建的handler通过调用obtainmessage方法可以得到想要传递的消息，然后调用sendtotarget方法就可以将消息放到该activity的handler的消息队列中了，就实现了消息传到指定的activity。 之后的处理就有handlemessage来执行了。

可以的，只要是在主线程创建的handler

class Test extends Activity{ private Handler mhandler = new Handler(){ public void handleMessage(Message msg){ }}；

应该用public class HandlerActivity extends Activity{}

Service、handler和thread之间没关系。Service是android的四大组件之一。其它几个是activity、broadcast和contentprovider。handler和thread有一定的关系，但也不是必须的，如果在thread中要更新UI，需要使用handler同步更新。

------解决方案--------------------Looper.loop(); 之后 需要做啥？Lopper myLopper = null;new Thread(){ public void run(){ Looper.prepare(); myLopper = Lopper.myLooper(); Looper.loop(); }}.start();class Threadhandler extends Handler { public void handleMessage(Message msg) { }}Threadhandler handler = new Threadhandler(myLopper);------解决方案--------------------楼主牛逼，这啥需求？语句执行到Looper.loop();后，线程会阻塞在这里，后面的语句根本无法执行。除非让loop()消息循环退出(可以调用quit()函数)，否则根本无法按照你的需求来实现。/** * Run the message queue in this thread. Be sure to call * {@link #quit()} to end the loop. */ public static void loop() { final Looper me = myLooper(); if (me == null) { throw new RuntimeException("No Looper; Looper.prepare() wasn"t called on this thread."); } final MessageQueue queue = me.mQueue;// Make sure the identity of this thread is that of the local process, // and keep track of what that identity token actually is. Binder.clearCallingIdentity(); final long ident = Binder.clearCallingIdentity();for (;;) { Message msg = queue.next(); // might block if (msg == null) { // No message indicates that the message queue is quitting. return; }// This must be in a local variable, in case a UI event sets the logger Printer logging = me.mLogging; if (logging != null) { logging.println(">>>>> Dispatching to " + msg.target + " " + msg.callback + ": " + msg.what); }msg.target.dispatchMessage(msg); if (logging != null) { logging.println("<<<<< Finished to " + msg.target + " " + msg.callback); }// Make sure that during the course of dispatching the // identity of the thread wasn"t corrupted. final long newIdent = Binder.clearCallingIdentity(); if (ident != newIdent) { Log.wtf(TAG, "Thread identity changed from 0x" + Long.toHexString(ident) + " to 0x" + Long.toHexString(newIdent) + " while dispatching to " + msg.target.getClass().getName() + " " + msg.callback + " what=" + msg.what); }msg.recycle(); } }

在开发过程中，我们经常会遇到这样一种情况，当在Activity中使用handler时，直接创建匿名内部类，会得到一个警告，意思是可能出现内存泄漏，推荐使用静态内部类。这也是面试时经常被问的一个问题，现在，我们就来解读一下为什么会出现这个警告，以及如何改进。 我们知道，Handler在使用时，通过post或者send的方式，可以把消息发送到MessageQueue队列中，期间Looper循环取出消息去交给对应的handler所在的线程去处理，有些消息还加上了延时发送，这些原因就可能会导致一个问题：当Activity销毁了，而主线程中一直运行的Looper会持有handler的引用，而我们在创建handler的时候用的是非静态匿名内部类，所以此handler会持有Activity的引用，导致Activity不会被回收，出现了内存泄漏。因此，编译器才会给我们一个这样的警告。 可能有些朋友会疑惑为什么Looper会持有handler的引用，这就要看源码了： 不管我们调用post还是send方式发送消息，最终调用的都是sendMessageAtTime方法，而在这个方法中最后调用了enqueueMessage方法，我们来看一下Handler中enqueueMessage的源码： 可以看到msg.target被赋值给本类对象，也就是我们在activity中创建的handler。也就是说我们在发送Message时，这个消息就把handler给封装进了自己的内部，只要Message对象不被销毁，此handler对象就会一直存在，而此Message会一直存储在MessageQueue消息队列中，直到Looper取出交给handler处理。可以看到Looper的loop()方法的源码如下： 交给handler处理完后会回收该消息： 这样Looper才能断开与Handler对象的引用，直到这个时候，外部的Activity才可能被回收。因此，在使用handler的时候，不建议再这么使用了。 那么我们该怎样正确的使用呢？ 可以将Handler声明为Activity里的一个静态内部类，内部创建一个WeakReference，将Activity实例用弱引用存起来，这样就可以了。如果为了方便复用，也可以将Handler单独提出来作为一个类，原理相同。如下： 采用静态内部类或者单独提出来的作用是让handler对象不再持有activity对象的引用，而对外部activity的使用都是采用弱引用的方式，当垃圾回收器发现此activity只有弱引用时，就会回收它，这样就不会导致内存泄漏了。 好了，这个问题就解读到这里。下面我们再来看看一些相关的题外知识。 我们平常在使用Looper的时候，必须先调用Looper.prepare()方法，因为此方法会初始化一个Looper（并初始化一个MessageQueue）并和当前线程绑定，只有这些初始化工作完成后，后边我们才能使用这些东西；然后需要调用Looper.loop()把MessageQueue消息队列在这个线程中运行起来。下面是prepare方法和创建looper实例的源码，其中sThreadLocal.set(new Looper(quitAllowed)实现了当前线程和looper的绑定。 但是平时我们在Activity中使用时，并未先调用prepare然后调用loop方法，为什么呢？我们来看看ActivityThread的main方法，此方法是应用程序的入口，源码如下： 根据源码得出，原来APP在启动的时候，系统已经自动为我们做了相关的初始化工作，这里的ActivityThread就是主线程（UI线程），这样我们在Activity中就可以直接创建handler使用了。当然我们也可以创建自己的Looper，下面我们来演示子线程中的Handler和主线程中的Handler的使用。 老样子，我们使用静态内部类，提供两个构造函数，无参的给主线程创建handler，有参数的给子线程用，只需提供一个在子线程中初始化的Loope即可。在handleMessage回调方法里打印出当前线程。 然后在主线程和子线程中分别创建各自的实例： 然后在另外一个子线程中使用两个handler发送消息： 可以看到打印的日志： 由此可以看出不管handler是在哪个线程中使用，发送的消息都会存储在创建此handler时对应的Looper所属的线程中（MessageQueue中），并最后交给这个handler的handleMessage方法进行处理，这样实现了线程之间的通信。最后总结： 1.在Activity中直接使用非静态内部类的Handler，提示会出现内存泄漏，因为非静态内部类对象会持有外部类对象的引用，如果此内部对象一直被引用着，就会导致外部类对象不会被回收。要么声明为静态，要么提出去单独作为一个文件类。并对Activity采用弱引用的方式来使用。 2.应用程序在启动阶段已经替我们做了Looper的初始化工作，我们在Activity中可以直接使用Handler。但是如果想在子线程中创建handler，必须先调用Looper.prepare()方法，然后调用Looper.loop()，这样才能使用handler。 3.线程--Looper--MessqgeQueue是一一对应的，由msg.target可以得出一个线程中可以创建多个handler，handler的使用（发送消息）可以在任何线程中，但是消息最终都是在创建此handler时对应的Looper所属线程中被处理的。这样也就实现了线程间通信。

u2003在理解了Handler的原理之后，我们知道在一个子线程中创建一个Handler不能缺少了Looper.prepare()和Looper.loop()两个方法，具体的原因这里不再赘述，不熟悉原理的可以先看下另一篇文章 Handler的原理解析 . 本篇文章主要是讲解HandlerThread的使用的。 u2003首先HandlerThread是继承于Thread类的，所以本质上HandlerThread就是一个线程，接下来就详细的去看一看，这是怎样的一个线程？ u2003首先，先看下它的构造函数： u2003既然是线程，那么最重要的当然是run方法来，看完了run方法，相信你也就明白HandlerThread的用途了！ u2003怎么样，这是不是和我们之前在子线程中创建Handler一样，首先是Looper.prepare(),接着是new Handler(), 最后是Looper.loop()。等等，这里并没有创建Handler啊！别急，我们先一步一步地看看run方法再说为什么没有创建Handler。 u2003通过查找发现到一个getLooper()的方法，该方法返回了当前线程的mLooper对象，还记得Looper是在哪里进行赋值的吗？在线程的run方法里，所以当线程启动之后才能创建Looper并赋值给mLooper，这里的阻塞就是为了等待Looper的创建成功。同时该方法是用Public修饰的，说明该方法是提供外部调用的，Looper创建成功提供给外部使用。 u2003最后在对象销毁前，调用下面的方法退出Looper循环 u2003quit方法实际是调用MessagQueue的removeAllMessagesLocked，移除所有延迟和非延迟的消息， u2003quitSafely方法调用的是removeAllFutureMessagesLocked方法，该方法只清除延迟的消息，非延迟的消息 还是会进行分发处理。 u2003HandlerThread分析完啦，是不是有点蒙，自始至终都没有出现Handler，HandlerThread要怎么用呢？ u2003下面我们就通过一个Demo来说明下HandlerThread是怎么用的？

我们从报错开始追踪：“Can"t create handler inside thread that has not called Looper.prepare()” —-》 错误日志就来自Handler的默认构造方法，源码如下：/*** Default constructor associates this handler with the queue for the* current thread.** If there isn"t one, this handler won"t be able to receive messages.*/public Handler() {if (FIND_POTENTIAL_LEAKS) {final Class<? extends Handler> klass = getClass();if ((klass.isAnonymousClass() || klass.isMemberClass() || klass.isLocalClass()) &&(klass.getModifiers() & Modifier.STATIC) == 0) {Log.w(TAG, "The following Handler class should be static or leaks might occur: " +klass.getCanonicalName());}}mLooper = Looper.myLooper();if (mLooper == null) { //当mLooper为null时就会报这个异常throw new RuntimeException("Can"t create handler inside thread that has not called Looper.prepare()");}mQueue = mLooper.mQueue;mCallback = null;}—-》 那么我看下myLooper这个方法：/*** Return the Looper object associated with the current thread. Returns* null if the calling thread is not associated with a Looper.*/public static Looper myLooper() {return sThreadLocal.get();}很明显这里只是从sThreadLocal这个当前线程的对象身上获取到一个Looper。 —-》 那么我们需要知道这个Looper是什么时候被赋值到当前线程的对象上面的，Looper类中有一个prepare方法/** Initialize the current thread as a looper.* This gives you a chance to create handlers that then reference* this looper, before actually starting the loop. Be sure to call* {@link #loop()} after calling this method, and end it by calling* {@link #quit()}.*/public static void prepare() {prepare(true);}private static void prepare(boolean quitAllowed) {if (sThreadLocal.get() != null) {throw new RuntimeException("Only one Looper may be created per thread");}sThreadLocal.set(new Looper(quitAllowed));//在这里创建一个Looper对象并赋值给当前线程}—-》 那么这个Looper.prepare（）方法是什么时候在哪里调用的呢？ 当我们在主线程中创建Handler对象的时候没有问题，是因为主线程会自动调用Looper.prepare（）方法去 给当前主线程创建并设置一个Looper对象，随意在Handler构造函数中从当前线程的对象身上拿到这个Looper。 但是子线程中并不会自动调用这个方法，所以要想在子线程中创建Handler对象就必须在创建之前手动调用Looper.prepare（）方 法，否则就会报错。

一、Handler的定义: Handler主要接收子线程发送的数据, 并用此数据配合主线程更新UI，用来跟UI主线程交互用。比如可以用handler发送一个message，然后在handler的线程中来接收、处理该消息，以避免直接在UI主线程中处理事务导致影响UI主线程的其他处理工作，Android提供了Handler作为主线程和子线程的纽带；也可以将handler对象传给其他进程，以便在其他进程中通过handler给你发送事件；还可以通过handler的延时发送message，可以延时处理一些事务的处理。通常情况下，当应用程序启动时，Android首先会开启一个主线程 (也就是UI线程) , 主线程为管理界面中的UI控件，进行事件分发。如果此时需要一个耗时的操作，例如:联网读取数据，或者读取本地较大的一个文件的时候，你不能把这些操作放在主线程中，如果你放在主线程中的话，界面会出现假死现象,如果5秒钟还没有完成的话，会收到Android系统的一个错误提示"强制关闭". 这个时候我们需要把这些耗时的操作，放在一个子线程中,因为子线程涉及到UI更新，但是当子线程中有涉及到操作UI的操作时，就会对主线程产生危险，也就是说，更新UI只能在主线程中更新，在子线程中操作是危险的. 这个时候，Handler就出现了来解决这个复杂的问题，由于Handler运行在主线程中(UI线程中)，它与子线程可以通过Message对象来传递数据，这个时候，Handler就承担着接受子线程传过来的(子线程用sedMessage()方法传递)Message对象，(里面包含数据), 把这些消息放入主线程队列中，配合主线程进行更新UI。二、Handler一些特点 handler可以分发Message对象和Runnable对象到主线程中, 每个Handler实例,都会绑定到创建他的线程中(一般是位于主线程), 也就是说Handler对象初始化后，就默认与对它初始化的进程的消息队列绑定，因此可以利用Handler所包含的消息队列，制定一些操作的顺序。三、Handler中分发消息的一些方法 post(Runnable) postAtTime(Runnable,long) postDelayed(Runnable long) post类方法允许你排列一个Runnable对象到主线程队列中 sendEmptyMessage(int) sendMessage(Message) sendMessageAtTime(Message,long) sendMessageDelayed(Message,long) sendMessage类方法, 允许你安排一个带数据的Message对象到队列中，等待更新.四、应用实例： 1，传递Message。用于接受子线程发送的数据, 并用此数据配合主线程更新UI。 在Android中，对于UI的操作通常需要放在主线程中进行操作。如果在子线程中有关于UI的操作，那么就需要把数据消息作为一个Message对象发送到消息队列中，然后，用Handler中的handlerMessge方法处理传过来的数据信息，并操作UI。类sendMessage(Message msg)方法实现发送消息的操作。 在初始化Handler对象时重写的handleMessage方法来接收Messgae并进行相关操作。 2，传递Runnable对象。用于通过Handler绑定的消息队列，安排不同操作的执行顺序。Handler对象在进行初始化的时候，会默认的自动绑定消息队列。利用类post方法，可以将Runnable对象发送到消息队列中，按照队列的机制按顺序执行不同的Runnable对象中的run方法。另外，Android的CPU分配的最小单元是线程，Handler一般是在某个线程里创建的，因而Handler和Thread就是相互绑定的，一一对应。而Runnable是一个接口，Thread是Runnable的子类。所以说，他俩都算一个进程。 视频教程中的例子：1. public class HandlerActivity extends Activity { 2. 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对象和消息。 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. // HandlerThread顾名思义就是可以处理消息循环的线程，它是一个拥有Looper的线程16. ，可以处理消息循环； 其实与其说Handler和一个线程绑定，倒不如说Handler和Looper是17. 一一对应的。18. MyHandler myHandler = new MyHandler(handlerThread.getLooper()); 19. Message msg = myHandler.obtainMessage(); 20. //将msg发送到目标对象，所谓的目标对象，就是生成该msg对象的handler对象 21. Bundle b = new Bundle(); 22. b.putInt("age", 20); 23. b.putString("name", "Jhon"); 24. msg.setData(b); 25. msg.sendToTarget(); //将msg发送到myHandler26. } 27. 28. //定义类29. class MyHandler extends Handler{ 30. public MyHandler(){ 31. 32. } 33. 34. public MyHandler(Looper looper){ 35. super(looper); 36. } 37. @Override 38. public void handleMessage(Message msg) { 39. Bundle b = msg.getData(); 40. int age = b.getInt("age"); 41. String name = b.getString("name"); 42. System.out.println("age is " + age + ", name is" + name); 43. System.out.println("Handler--->" + Thread.currentThread().getId()); 44. System.out.println("handlerMessage"); 45. } 46. } 47. } 这样，当使用sendMessage方法传递消息或者使用post方法传递Runnable对象时，就会把它们传递到与handler对象绑定的处于另外一个线程的消息队列中，它们将在另外的消息队列中被处理。而主线程还会在发送操作完成时候继续进行，不会影响当前的操作。这里需要注意，这里用到的多线程并非由Runnable对象开启的，而是ThreadHandler对象开启的。Runnable对象只是作为一个封装了操作的对象被传递，并未产生新线程。另外再强调一遍，在UI线程（主线程）中： mHandler=new Handler(); mHandler.post(new Runnable(){ void run(){ //执行代码.. } }); 这个线程其实是在UI线程之内运行的，并没有新建线程。 常见的新建线程的方法是： Thread thread = new Thread(); thread.start(); HandlerThread thread = new HandlerThread("string"); thread.start();

在Android中，Handler是一种消息处理机制，主要用于在不同线程之间传递消息和处理消息。在Activity中，通常会使用Handler来处理异步任务中的消息，例如网络请求、后台处理等。在Activity中使用Handler的步骤如下：1. 在Activity中定义一个Handler对象，并重写handleMessage()方法，该方法用于处理消息。2. 在Activity中创建一个子线程，并在子线程中使用Handler的sendMessage()方法向主线程发送消息。3. 在主线程中，Handler会收到发送的消息，并根据不同的消息类型执行对应的操作。以下是一个示例代码，演示了如何在Activity中使用Handler处理异步任务中的消息：```public class MainActivity extends AppCompatActivity { private static final int MSG_NETWORK_REQUEST = 1; private static final int MSG_UPDATE_UI = 2; private Handler mHandler; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); // 创建Handler对象，并重写handleMessage()方法 mHandler = new Handler() { @Override public void handleMessage(Message msg) { switch (msg.what) { case MSG_NETWORK_REQUEST: // 处理网络请求结果 break; case MSG_UPDATE_UI: // 更新UI break; } } }; // 在子线程中使用Handler的sendMessage()方法向主线程发送消息 new Thread(new Runnable() { @Override public void run() { // 执行网络请求等耗时操作 // 发送消息 mHandler.sendEmptyMessage(MSG_NETWORK_REQUEST); } }).start(); }}```需要注意的是，Handler需要在主线程中创建，因此在Activity中创建Handler时不需要使用runOnUiThread()方法。同时，在使用Handler处理消息时，需要注意线程间的同步和数据安全等问题。

handler这个属性用于指定事件处理的函数。比如你在一个按钮构造的时候指定它的属性 handler:function(){ alert("Hello"); }那么你在点击这个按钮的时候，就会执行handler后面的函数(这里是一个匿名函数)，弹出一个文本内容为Hello的对话框。

单击事件。

子线程中可以使用Handler的。但容易出现异常。在使用Handler时，经常会出现以下两个异常：（1）CalledFromWrongThreadException：这种异常是因为尝试在子线程中去更新UI，进而产生异常。（2）Can"t create handle inside thread that ha not called Looper.prepared：是因为我们在子线程中去创建Handler，而产生的异常。

如果你不带参数的实例化：Handler handler = new Handler();那么这个会默认用当前线程的looper一般而言，如果你的Handler是要来刷新操作UI的，那么就需要在主线程下跑。情况:1.要刷新UI，handler要用到主线程的looper。那么在主线程 Handler handler = new Handler();，如果在其他线程，也要满足这个功能的话，要Handler handler = new Handler(Looper.getMainLooper());2.不用刷新ui,只是处理消息。 当前线程如果是主线程的话，Handler handler = new Handler();不是主线程的话，Looper.prepare(); Handler handler = new Handler();Looper.loop();或者Handler handler = new Handler(Looper.getMainLooper());懂了吗不懂可以继续提问，嘿嘿 查看原帖>>

在 Linux 中，epoll 机制是一个重要的机制。在 Android 中的 Handler，简单的利用了 epoll 机制，做到了消息队列的阻塞和唤醒。 epoll 机制相关的函数有 因为对于Handler 对于 epoll 没有过于深入的使用，只是利用了 epoll 进行了阻塞和唤醒，还是比较好理解的。 于是，便利用 epoll 机制在mEpollFd上添加(EPOLL_CTL_ADD)了监听的 fd(mWakeEventFd); 在 java 层，next( )@Message 会阻塞到nativePollOnce(long ptr, int timeoutMillis)，特别的是，当没有消息时，timeoutMillis = -1表示一直阻塞。如果有 delay 的消息，则 timeoutMillis 表示 delay的时间。 此时利用epoll 机制在 epoll_wait()上设置超时时间。当 timeoutMillis = -1时会一直等待知道有新消息来。否则当超时时间到达时，会返回到 next()@Message就可以处理那条 delay 的消息了。 当有新消息来临时并且是立刻执行的,enqueueMessage()@Message 会调用nativeWake()，否则会根据新来的消息的 delay 时间和队列中的 delay 时间进行对比，消息队列是按照msg 的到达时间和 delay 时间进行排序，如果新来的消息在前并且需要 delay 也会进行 wake() 当往 mWakeEventFd 写入一个 1，便会从 epoll_wait() 马上返回。进行新一轮的消息处理。 另外，native 层的 Looper 的 epoll 机制没有这么简单，只是在 Handler 中只是简单地使用了。 Linux中的epoll

一般来说在工作线程中执行耗时任务，当任务完成时，会返回UI线程，一般是更新UI。这时有两种方法可以达

通俗的解释就是: Thread处理Handler发送过来的消息，每个Thread都要有一个消息处理队列(MessageQueue),用于存放handler发送过来的消息。Thread为一个while(true)无限循环，每次从消息队列取出消息，并且回调Handler的消息处理函数（handlerMessage）。

Handler主要用于异步消息的处理：当发出一个消息之后，首先进入一个消息队列，发送消息的函数即刻返回，而另外一个部分在消息队列中逐一将消息取出，然后对消息进行处理，也就是发送消息和接收消息不是同步的处理。 这种机制通常用来处理相对耗时比较长的操作。一、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实例子类需要继承Hendler类，并重写handleMessage(Message msg) 方法， 用于接受线程数据。

百度一下一大把，不是百度知道几百个字可以说清楚的。

　　在Android中，对于UI的操作通常需要放在主线程中进行操作。如果在子线程中有关于UI的操作，那么就需要把数据消息作为一个Message对象发送到消息队列中，然后，用Handler中的handlerMessge方法处理传过来的数据信息，并操作UI。类sendMessage(Message msg)方法实现发送消息的操作。 在初始化Handler对象时重写的handleMessage方法来接收Messgae并进行相关操作。　　传递Runnable对象。用于通过Handler绑定的消息队列，安排不同操作的执行顺序。　　Handler对象在进行初始化的时候，会默认的自动绑定消息队列。利用类post方法，可以将Runnable对象发送到消息队列中，按照队列的机制按顺序执行不同的Runnable对象中的run方法。　　另外，Android的CPU分配的最小单元是线程，Handler一般是在某个线程里创建的，因而Handler和Thread就是相互绑定的，一一对应。而Runnable是一个接口，Thread是Runnable的子类。所以说，他俩都算一个进程。

andriod提供了 Handler 和 Looper 来满足线程间的通信。Handler 先进先出原则。Looper类用来管理特定线程内对象之间的消息交换(Message Exchange)。　　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。

首先明白创建Handler时，要与哪一个线程关联，通过Looper对象关联起来的。与哪个线程关联，就处理哪个线程的消息队列，消息任务就在那个线程中执行。所以handler可以在主线程中创建，也可以在子线程中创建。创建Handler实例时，没有传递Looper对象，那么在哪个线程中创建就与哪个线程关联。创建Handler实例时，传递线程的Looer对象，就与Looper所在的线程关联。

我知道你这个他有哪几个shaat第二那这个肯定非常多的那个可能那个他的

Handler对象与其调用者在同一线程中，如果在Handler中设置了延时操作，则调用线程也会堵塞。每个Handler对象都会绑定一个Looper对象，每个Looper对象对应一个消息队列（MessageQueue）。如果在创建Handler时不指定与其绑定的Looper对象，系统默认会将当前线程的Looper绑定到该Handler上。在主线程中，可以直接使用new Handler()创建Handler对象，其将自动与主线程的Looper对象绑定；在非主线程中直接这样创建Handler则会报错，因为Android系统默认情况下非主线程中没有开启Looper，而Handler对象必须绑定Looper对象。这种情况下，需先在该线程中手动开启Looper（Looper.prepare()--gt;Looper.loop()），然后将其绑定到Handler对象上；或者通过Looper.getMainLooper()，获得主线程的Looper，将其绑定到此Handler对象上。Handler发送的消息都会加入到Looper的MessageQueue中。一说Handler包含两个队列：线程队列和消息队列；使用Handler.post()可以将线程对象加入到线程队列中；使用Handler.sendMessage()可以将消息对象加入到消息队列中。通过源码分析证实，Handler只有一个消息队列，即MessageQueue。通过post()传进去的线程对象将会被封装成消息对象后传入MessageQueue。使用post()将线程对象放到消息队列中后，当Looper轮询到该线程执行时，实际上并不会单独开启一个新线程，而仍然在当前Looper绑定的线程中执行，Handler只是调用了该线程对象的run()而已。如，在子线程中定义了更新UI的指令，若直接开启将该线程执行，则会报错；而通过post()将其加入到主线程的Looper中并执行，就可以实现UI的更新。使用sendMessage()将消息对象加入到消息队列后，当Looper轮询到该消息时，就会调用Handler的handleMessage()来对其进行处理。再以更新UI为例，使用这种方法的话，就先将主线程的Looper绑定在Handler对象上，重载handleMessage()来处理UI更新，然后向其发送消息就可以了。

它实现不同线程间通信的一种机制。关于Handler的说法正确的是(）A,它实现不同线程间通信的一种机制。B,它不能在新线程中执行刷新UI的操作。C,它采用栈的方式来组织任务的。D,它可以属于一个新的线程。A正确。B是因为handler+looper+Messagequeue这种方式来更新UI；CHandler采用的是消息队列的方式，每一个Handler都会有一个与之相关联的消息队列，而且都是以先进先出的方式执行；D则是因为handler属于创建它的线程。

不是的，有以下两种：一，如果不带参数的实例化：Handler handler = new Handler();那么这个会默认用当前线程的looper。二，一般而言如果Handler是要来刷新操作UI的，那么就需要在主线程下跑。那么在主线程 Handler handler = new Handler()。三，如果在其他线程，也要满足这个功能的话，要Handler handler = new Handler(Looper.getMainLooper());不用刷新ui,只是处理消息。 四，当前线程如果是主线程的话，Handler handler = new Handler();不是主线程的话，Looper.prepare(); Handler handler = new Handler();Looper.loop();或者Handler handler = new Handler(Looper.getMainLooper())。

Message message = Message.obtain();new 一个 查看原帖>>

用这个方法hasMessages(int what)循环一下private boolean isHandlerMsgEmpty(Handler handler){for(...) { isEmpty = handler.hasMessages(int what);if(!isEmpty )break;}return isEmpty ;}

当请求发生时， DispatcherServlet 将请求递交给 hangler mapping, 让其检测请求并提出一个

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)：指定多少毫秒之后发送消息。

Handler主要用于异步消息的处理：当发出一个消息之后，首先进入一个消息队列，发送消息的函数即刻返回，而另外一个部分在消息队列中逐一将消息取出，然后对消息进行处理，也就是发送消息和接收消息不是同步的处理。 这种机制通常用来处理相对耗时比较长的操作。在计算机编程语言中，Event 对象代表事件的状态，比如事件在其中发生的元素、键盘按键的状态、鼠标的位置、鼠标按钮的状态。事件通常与函数结合使用，函数不会在事件发生前被执行

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)：指定多少毫秒之后发送消息。

有两种方式：使用默认的构造方法：newHandler()。使用带参的构造方法，参数是一个Runnable对象或者回调对象。

关于Handler的说法不正确的是 A.它实现不同进程间通信的一种机制 B.它避免了在新线程中操作UI的操作 C.它采用队列的方式来存储Message D.它实现不同线程间通信的一种机制 正确答案：

不明白··· 还是不明吧

简单来说，Handler这个类就是管理某个线程(也可能是进程)的消息队列，比如让Handler处理主线程的消息队列，这样就可以将一些耗时任务放到其他线程之中，待任务完成之后就往主线程的消息队列中添加一个消息，这样Handler的Callback，即handleMessage就会被调用。但是Handler并不是线程安全的，因此官方文档中建议将Handler作为一个静态内部类。所以Handler只是处理消息，耗时任务放在其他线程。这是我当时的一篇读后感，应该对你会有帮助：http://zhouhaibing.diandian.com/post/2013-08-28/40053560489

Handler handler1 = new Handler() {@Overridepublic void handleMessage(Message msg) {if (msg.what == 1) {}}};Message message = handler1.obtainMessage();message.what = 1;handler1.sendMessage(message);

handler.sendMessage(handler.obtainMessage(100,str));相当于：Message msg=new Message(); msg.what=100; msg.obj="123"; handler.sendMessage(msg);what是要做什么事的一个标识Handler handler = new Handler() { public void handleMessage(android.os.Message msg) { if(msg.what==100)//赋值 tv.setText(msg.obj+""); }; };

这个怎么翻译，应该不重要吧......晓得意思，怎么用就可以了呀.....这个一般是在KeyPress事件中的参数KeyPressEventArgse所具有的参数，e.Handler可以将它的值设为true或false当e.Handler=true的时候，就是阻止用户输入，为false就是允许用户输入。要是硬要翻译的话，可以把他联系事件翻译成：输入事件的控制者吧......

handler的英文是处理的意思。当中断事件发生时，MCU的PC指针会跳转到对应的中断入口，如复位发生，系统自动跳转到0地址处，汇编文件中在该地址放一条跳转指令跳转到对应的函数执行中断处理。各编译器的约定是采用xxxx_handler的形式，所以都有handler。这只是个约定而已，可以自己修改.s的跳转函数

主线程易阻塞，所以创建多线程，由子线程发消息给主线程，由主线程刷新ui

1. 传递Message。用于接受子线程发送的数据, 并用此数据配合主线程更新UI。在Android中，对于UI的操作通常需要放在主线程中进行操作。如果在子线程中有关于UI的操作，那么就需要把数据消息作为一个Message对象发送到消息队列中，然后，由Handler中的handlerMessage方法处理传过来的数据信息，并操作UI。当然，Handler对象是在主线程中初始化的，因为它需要绑定在主线程的消息队列中。类sendMessage(Message msg)方法实现发送消息的操作。 在初始化Handler对象时重写的handleMessage方法来接收Message并进行相关操作。2. 传递Runnable对象。用于通过Handler绑定的消息队列，安排不同操作的执行顺序。Handler对象在进行初始化的时候，会默认的自动绑定消息队列。利用类post方法，可以将Runnable对象发送到消息队列中，按照队列的机制按顺序执行不同的Runnable对象中的run方法。

Handler这个类就是管理某个线程(也可能是进程)的消息队列，比如让Handler处理主线程的消息队列，这样就可以将一些耗时任务放到其他线程之中，待任务完成之后就往主线程的消息队列中添加一个消息，这样Handler的Callback，即handleMessage就会被调用。但是Handler并不是线程安全的，因此官方文档中建议将Handler作为一个静态内部类。所以Handler只是处理消息，耗时任务放在其他线程。Handler的使用主要是android中无法在主线程（即UI线程）中访问网络、无法在子线程中访问UI线程元素。一般是在子线程中访问网络，然后使用Handler发送message通知主线程处理UI更新操作。

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对于Android开发者再熟悉不过了，也是面试题的常客了，所以了解Handler机制的源码就很有必要了，虽然Handler分析的文章已经有很多，但是自己总结一遍，印象才更深刻。 Handler机制，是Android中的一种消息传递机制，在开发中十分常用。由于Android从3.0开始不允许耗时操作在主线程中执行，必须在子线程中执行完后，将结果发送到主线程中更新UI。所以简单来讲Handler就是子线程和主线程通信的一种技术。 先是常规使用，Handler在主线程中创建，开启子线程处理耗时操作，再通过Handler发送消息到主线程，Handler的handleMessage()方法就会被回调，再更新UI。 以及也很常用的，post()和postDelayed()。 还有一种场景，就是子线程中创建Handler，让子线程成为轮训的线程，接收其他线程的消息，开发中并不多，但是特定场景会很有用，例如有一个一直执行的子线程，一直定时扫描着当前位置信息，到了指定范围，发送一个播放语音的消息的消息到主线程。 接下来就是Handler源码分析了： 一般我们获取Message会调用Handler的obtainMessage()方法，这个方法是获取一个复用的Message对象，内部采用享元模式复用Message对象，在Android中，View绘制，Activity生命周期，都是使用Handler发送Message实现，如果每次都new一个消息对象，肯定是十分消耗内存的，也容易产生GC垃圾回收导致卡顿。 我们平常在主线程使用Handler时，并没有调用过Looper.prepare()和Looper.loop()这2个方法，为什么创建Handler时不会抛出异常呢？ 原因就是创建Handler时，调用Looper.myLooper()获取主线程绑定的Looper不为空，所以没有抛出异常。经过Looper类中查找发现，除了Looper.prepare()之外，还有一个prepareMainLooper()的方法。 prepareMainLooper()方法的注释，意思大概就是，创建主线程的Looper对象，该方法由Android框架在主线程自动调用，我们不应该主动调用该方法。 那么什么时候会调用prepareMainLooper()方法呢，AndroidStudio点击方法查找调用链，我们发现在ActivityThread中有调用。ActivityThread是Android程序的主线程，main方法则是启动的方法，我们看到先是调用了Looper.prepareMainLooper()，初始化主线程的Looper。再调用了Looper.loop()开启主线程轮训。

Handler就是解决线程与线程间的通信。 当我们在子线程处理耗时操作，耗时操作完成后我们需要更新UI的时候，这就是需要使用Handler来处理了，因为子线程不能更 新UI，Handler能让我们容易的把任务切换回来它所在的线程。 消息处理机制本质：一个线程开启循环模式持续监听并依次处理其他线程给它发的消息。 一个线程可以有多个Handler，通过new Handler的方式创建。 一个线程只能有一个Looper，通过Looper.perpare方法会创建一个Looper保存在ThreadLocal中，每个线程都有一个LocalThreadMap，会将Looper保存在对应线程中的LocalThreadMap，key为ThreadLocal，value为Looper。 内部类持有外部类的对象，handler持有activity的对象，当页面activity关闭时，handler还在发送消息，handler持有activity的对象，导致handler不能及时被回收，所以造成内存泄漏。 因为当handler发送消息时，会有耗时操作，并且会利用线程中的looper和messageQueue进行消息发送，looper和messageQueue的生命周期是很长的，和application一样，所以handler不容易被销毁，所以造成内存泄漏。 解决方案有： 可以在子线程中创建Handler，我们需要调用Looper.perpare和Looper.loop方法。或者通过获取主线程的looper来创建Handler。 应该调用Looper的quit方法，因为可以将looper中的messageQueue里的message都移除掉，并且将内存释放。 通过synchronized锁机制保证线程安全。 Message.obtain来创建Message。这样会复用之前的Message的内存，不会频繁的创建对象，导致内存抖动。 点击按钮的时候会发送消息到Handler，但是为了保证优先执行，会加一个标记异步，同时会发送一个target为null的消息，这样在使用消息队列的next获取消息的时候，如果发现消息的target为null，那么会遍历消息队列将有异步标记的消息获取出来优先执行，执行完之后会将target为null的消息移除。(同步屏障) 更多内容戳这里（整理好的各种文集）

Handler和Interceptor是有区别的，Handler能拦截静态和动态所有资源请求，Interceptor只拦截controller和action。如果你的权限不处理静态资源，那就Interceptor，如果包含静态资源，那就Handler。一般来说用Interceptor多些。

PHP有内置的操作 session 的save_handler。通过 session_set_save_handler 是方便开发人员自己定义相关的处理方式，比如我们要保存 session 到数据库，或者是我们在 session 开启时要做些自己想要的操作等等。1、session_start 调用时，或者 session 自动启动时，PHP将会调用 open 和 read 这两个 save_handler，这不是有人说的，而是PHP文档里说的。2、要使用session，每个脚本页面需要 session_start。3、session_set_save_handler 定义好之后，根据不同 session 操作，会调用不同的方法。比如上面说的 session_start 就会使用 open 和 read 两个处理方法。4、这个问题看的不是很明白，无法回答。

不知你在Springboot应用开发中有没有遇到过这样的情况,http请求进来却没有到达指定的controller就返回响应了,这是有可能在哪里拦截了呢。 答案是Filter，HandlerInterceptor，Aspect都有可能拦截，下面简单分析一下它们几个。 要说清它们关系得加上异常处理,在 Springboot 开发中默认的异常处理有三层,分别有 ErrorPage , ErrorController , RestControllerAdvice ,一次请求的调用链路简化图如下① DispatcherServlet 是 Spring 框架定义的 Servlet ,在 Tomcat 中作为默认的 Servlet ,是联通 Tomcat 和 Spring 的关键节点,负责分发http请求到对应的 Controller 中处理。 ② 请求建立socket链接后,先经过 Tomcat 的数个 valve ，开始进入 Filter ,再到 HandlerInterceptor , Aspect ,最后才到达 Controller 的,而相应的返回路径正好相反,先从 Controller ,最后到 Filter 。 ③ 当在 HandlerInterceptor 和 Aspect 发生异常时,如果我们定义了 @RestControllerAdvice 和 @ExceptionHandler ,那么会在 DispatcherServlet 处理中,把异常交给我们定义的方法来处理。如果没有定义则往上抛异常。 ④ 如果没有定义 @ExceptionHandler 或者 Filter 中发生异常时，将会在 StandardHostValve中 寻找匹配的 ErrorPage ，默认情况下，会将请求交给定义了/error路径的 Controller 处理,在 Springboot 中,默认会交给 BasicErrorController 处理, 因为是在 StandardHostValve 发起的链路,所以 Filter , HandlerInterceptor , Aspect 都会重新走一遍,但是有一点不同的是,这条链路只会调用类型为error的 Filter ,所以我们自定义的 Filter 不会重新调用。 ⑤ 如果前面两道防线都失守了，或者③的异常处理链路中再次发生异常，那么将会在 ErrorReportValve 中处理异常，这时候处理异常比较简单粗暴，直接读取匹配的html文件，如果没有找到html文件，就会拼接一个固定样式的html报文响应回去。

invalid parameter handler无效的参数处理程序例句筛选1.The image parameter handler will be automatically invoked whenthat template is displayed.在显示该模板时，将自动调用图像参数处理程序。2.The comment parameter handler has three possible modes,depending on the parameters passed to it.根据传入的参数，评论参数处理程序有三个可能的模式。

最近，多种软件都出现了一个启动时的错误提示“无法定位程序输入点_except_handler4_common于动态链接库msvcrt.dll上”。出现这个提示情况是：WindowsXp系统；软件包括：windowlivewriter2009,windowsmessenger2009,firefox3.5等非常新的版本。这个提示出现后，点击确定，并不影响程序的使用。这个问题出现的原因，其实微软自己的问题。可谓是微软的Vista后遗症吧。在Vista系统里，有个挺酷的功能，就是“程序缩略图”，有点3D效果，这个功能，调用了dwmapi.dll这个库，而dwmapi.dll又引用了msvcrt.dll中的_except_handler4_common功能。然而，在XP系统中，系统自带的msvcrt.dll和Vista中的msvcrt.dll版本不同，并没有这个_except_handler4_common，结果就出现了启动程序时，遇到的“无法定位程序输入点_except_handler4_common于动态链接库msvcrt.dll上”的错误提示。解决方法：将c:windowssystem32下的dwmapi.dll改名，例如：改为dwmapi.dll.bak。就可以了，你可以试试。