hand

　　handle有处理;对待;操作;触;买卖;把手;柄等意思，那么你知道handle的用法吗?下面跟着我一起来学习handle的英语知识吧，希望对大家的学习有所帮助! 　 　handle的用法 　　handle的用法1：handle主要用作及物动词,宾语可以是人或事物; 　　handle的用法2：偶尔用作不及物动词,其主动形式往往表示被动意义。 　　 handle的常用 短语 　　用作名词 (n.) 　　give〔put〕 a handle to 　　给人以姓名 　　handle相关词汇辨析 　　deal with，cope with，dispose of，manage，handle 　　这些动词或短语动词都含有“处理”，“对付”之意。 　　deal with 既可指处理具体事情，也可指处理或解决具有抽象意义的问题。 　　cope with 指成功地处理或对付更为重大，更为严重的问题或事物。 　　dispose of 与deal with同义，普通用法。 　　manage 指处理日常事务与工作，也可指经营管理。 　　handle 从原义“手柄”，转引申为作“处理”解时，其内涵是管理和操纵。 　　 handle的用法例句 　　1. The public never had faith in his ability to handle the job. 　　公众从来不相信他有能力胜任这一职位。 　　2. Our plan is to allocate one member of staff to handle appoint-ments. 　　我们的计划是分派一位职员处理预约事宜。 　　3. Don"t take on more responsibilities than you can handle. 　　不要承担过多的责任。 　　4. He began informally to handle Ted"s tax affairs for him. 　　他开始非正式地为特德打理税务。 　　5. Some preteens are able to handle a good deal of responsibility. 　　有些青春期前的 儿童 能够承担很多责任。 　　6. The more powerful the car the more difficult it is to handle. 　　汽车的功率越大，就越难驾驭。 　　7. The device is manually operated, using a simple handle. 　　一只普通的手柄就可以手动操作这个装置。 　　8. I think I would handle a meeting with Mr. Siegel very badly. 　　我觉得和西格尔先生会谈我可能会搞得一团糟。 　　9. I knew how to load and handle a gun. 　　我知道怎么上子弹，也知道枪怎么用。 　　10. Tents have been set up next to hospitals to handle the overflow. 　　医院旁搭起了帐篷以安置容纳不下的人员。 　　11. The handle of a cricket bat protruded from under his arm. 　　一个板球拍柄从他的胳肢窝下面伸了出来。 　　12. I turned the handle and found the door was open. 　　我转了一下门把手，发现门开着。 　　13. He flew off the handle at the slightest thing. 　　他为一点小事就大发脾气。 　　14. Using a fabric conditioner will make clothes easier to handle and iron. 　　使用织物柔顺剂会使衣服打理、熨烫起来更为容易。 　　15. Some students have emotional problems that teachers feel ill equipped tohandle. 　　一些学生的情感问题令老师们束手无策。 猜你喜欢： 1. handle的过去式和用法例句 2. walk的用法和短语例句 3. dress的复数形式和用法例句 4. 代词语法讲解及练习题 5. belong的用法和短语例句 6. inspire的短语有哪些 7. easy的用法和短语例句

一般来说，handle就相当于C中的函数指针，你把哪个函数的句柄赋给handle，handle就代表哪个函数。当然，你也可以自己定义一个handle。

处理

除了各种API函数之外，句柄（HANDLE）没有使用必要。当一个函数要求句柄作为参数时，如果不是强调属性的函数，传递一个NULL就行了。否则以WinMain作为主函数，将主调函数的基础参数hInstance作为句柄传入。

I can handle the peoblem easily.望采纳～

handlein和dealin他们不同在于：当你想说“这件事我可以”的时候，如果用handle就会说“Icanhandlethisthing"但是如果想用deal的话就是“icandealwiththisthing"。

knob是旋钮；handle是把手

baidu:句柄handle可以理解成把柄你知道一个人的把柄你就可以牵着她走了handlehinstance是一样的，一般用再窗口上你要对窗口操作要获得她的句柄handle，门的把手

“句柄”是编译原理里面的术语，每个指令都是一个个语句，句柄相当于每一个对象的地址、编号等标识，用于区别指令作用的对象，就好像干洗店里每件衣服上挂着的标签，不同门上的把手，倒也不存在完全的不准确，所以就继续沿用下去了……至于“缺省”这类词，很蠢的翻译，现在都改为更准确的“默认”来代替。

handle主要用作及物动词,宾语可以是人或事物; 偶尔用作不及物动词,其主动形式往往表示被动意义。 短语搭配： valve handle阀门手柄 ; 阀门手轮 ; 阀杆 ; 阀柄 frank handle翰德乐 file handle文件句柄 ; 锉刀柄 ; 档案控制代码 ; 锉刀把 [1 扩展资料 　　You have to handle this. 　　你必须处理好这件事。 　　How do you handle it when someone hurts you? 　　那么，当有人伤害了你时，你应该怎样处理呢？ 　　How do I handle models that should have one and only one row in their database? 　　我要如何处理模型，应该在他们的数据库中有且仅有一个行吗？

handle可以用作动词，作及物动词,宾语可以是人或事物; 偶尔用作不及物动词,其主动形式往往表示被动意义。有处理，搬动等含义；作名词有把手，拉手等含义。1.handle主要用作及物动词,宾语可以是人或事物; 偶尔用作不及物动词,其主动形式往往表示被动意义。有处理，应付，控制等含义。 I was impressed by her handling of the affair. 我觉得她对此事的处理很了不起。 The speaker was roughly handled by the mob. 演说者受到暴民的粗暴对待。 He"s not a very good teacher---he doesn"t know how to handle children. 他不是一个好的老师---他不懂得如何对待孩子。 2.deal with，cope with，dispose of，manage，handle这些动词或短语动词都含有“处理”，“对付”之意。 deal with 既可指处理具体事情，也可指处理或解决具有抽象意义的问题。 cope with 指成功地处理或对付更为重大，更为严重的问题或事物。 dispose of 与deal with同义，普通用法。 manage 指处理日常事务与工作，也可指经营管理。 handle 从原义“手柄”，转引申为作“处理”解时，其内涵是管理和操纵。

deal 是偏重处理的主观能动性，比如遇到困难了知难而上handle 侧重操控，指对一个问题的控制能力tackle 指解决一个具体的难题

　　handle有操作，操控; 容易搬运等意思，那么你知道handle的同义词有哪些吗?下面我为大家带来handle的同义词及辨析，欢迎大家一起学习! 　　handle同义词： 　　deal with, cope with, dispose of, manage, handle 　　handle同义词辨析： 　　这些动词或短语动词都含有"处理，对付"之意。 　　deal with 既可指处理具体事情，也可指处理或解决具有抽象意义的问题。 　　cope with 指成功地处理或对付更为重大，更为严重的问题或事物。 　　dispose of deal with同义，普通用法。 　　manage 指处理日常事务与工作，也可指经营管理。 　　handle 从原义"手柄"，转引申为作"处理"解时，其内涵是管理和操纵。 　　handle的英语例句： 　　1. The public never had faith in his ability to handle the job. 　　公众从来不相信他有能力胜任这一职位。 　　2. Our plan is to allocate one member of staff to handle appoint-ments. 　　我们的计划是分派一位职员处理预约事宜。 　　3. Don"t take on more responsibilities than you can handle. 　　不要承担过多的责任。 　　4. He began informally to handle Ted"s tax affairs for him. 　　他开始非正式地为特德打理税务。 　　5. Some preteens are able to handle a good deal of responsibility. 　　有些青春期前的儿童能够承担很多责任。 　　6. The more powerful the car the more difficult it is to handle. 　　汽车的功率越大，就越难驾驭。 　　7. The device is manually operated, using a simple handle. 　　一只普通的手柄就可以手动操作这个装置。 　　8. I think I would handle a meeting with Mr. Siegel very badly. 　　我觉得和西格尔先生会谈我可能会搞得一团糟。 　　9. I knew how to load and handle a gun. 　　我知道怎么上子弹，也知道枪怎么用。 　　10. Tents have been set up next to hospitals to handle the overflow. 　　医院旁搭起了帐篷以安置容纳不下的人员。 　　11. The handle of a cricket bat protruded from under his arm. 　　一个板球拍柄从他的胳肢窝下面伸了出来。 　　12. I turned the handle and found the door was open. 　　我转了一下门把手，发现门开着。 　　13. He flew off the handle at the slightest thing. 　　他为一点小事就大发脾气。 　　14. Using a fabric conditioner will make clothes easier to handle and iron. 　　使用织物柔顺剂会使衣服打理、熨烫起来更为容易。 　　15. Some students have emotional problems that teachers feel ill equipped to handle. 　　一些学生的情感问题令老师们束手无策。

handle主要用作及物动词,宾语可以是人或事物; 偶尔用作不及物动词,其主动形式往往表示被动意义。 扩展资料 　　handle的意思 　　n. （织物、毛皮等的）手感,手柄,举动,柄状物 　　vi. 操作，操控,容易搬运 　　vt. 用双手触摸、举起或握住,用手操作，操纵,处理或负责，管理,〈美〉买卖，经营 　　变形：过去式: handled； 现在分词：handling； 过去分词：handled； 　　handle用法 　　handle可以用作动词 　　handle主要用作及物动词,宾语可以是人或事物; 偶尔用作不及物动词,其主动形式往往表示被动意义。 　　handle用作动词的用法例句 　　I was impressed by her handling of the affair.我觉得她对此事的.处理很了不起。 　　The speaker was roughly handled by the mob.演说者受到暴民的粗暴对待。 　　He"s not a very good teacher---he doesn"t know how to handle children.他不是一个好的老师---他不懂得如何对待孩子。 　　handle用法例句 　　1、The public never had faith in his ability to handle the job. 　　公众从来不相信他有能力胜任这一职位。 　　2、Our plan is to allocate one member of staff to handle appoint-ments. 　　我们的计划是分派一位职员处理预约事宜。 　　3、Don"t take on more responsibilities than you can handle. 　　不要承担过多的责任。

（1）handle with care（小心处理）：这个短语通常用于指某个物体需要小心处理，以免损坏。1. 名词用法三、总结2. 动词用法（2）Can you handle the pressure of this job?（你能承受这份工作的压力吗？）

handle和deal他们不同在于： 当你想说“这件事我可以”的时候,如果用handle 就会说 “I can handle this thing" 但是如果想用deal的话就是 “i can deal with this thing" .请注意如果用deal的话 别忘了WITH!

1、handle英[_h_ndl]美[_h_ndl]，n.手柄;柄;把手;把;拉手;提梁;有?个柄的;有?柄的;v.处理，应付(局势、人、工作或感情);(用手)触，拿，搬动;控制，操纵(车辆、动物、工具等);驾驶，操纵;买。2、[例句]Pickitupbythehandle!抓着手柄把它提起来！

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{}

------解决方案--------------------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（）方 法，否则就会报错。

android.os.Handler 　　Handler在android里负责发送和处理消息。它的主要用途有： 　　1）按计划发送消息或执行某个Runnanble(使用POST方法)； 　　2）从其他线程中发送来的消息放入消息队列中，避免线程冲突（常见于更新UI线程） 　　 默认情况下，Handler接受的是当前线程下的消息循环实例（使用Handler(Looper looper)、Handler(Looper looper, Handler.Callback callback)可以指定线程），同时一个消息队列可以被当前线程中的多个对象进行分发、处理（在UI线程中，系统已经有一个Activity来处理了，你可以再起若干个Handler来处理）。在实例化Handler的时候，Looper可以是任意线程的，只要有Handler的指针，任何线程也都可以sendMessage。Handler对于Message的处理不是并发的。一个Looper 只有处理完一条Message才会读取下一条，所以消息的处理是阻塞形式的（handleMessage()方法里不应该有耗时操作，可以将耗时操作放在其他线程执行，操作完后发送Message（通过sendMessges方法）,然后由handleMessage()更新UI）。 android中Handle类的用法 当我们在处理下载或是其他需要长时间执行的任务时，如果直接把处理函数放Activity的OnCreate或是OnStart中，会导致执行过程中整个Activity无响应，如果时间过长，程序还会挂掉。Handler就是把这些功能放到一个单独的线程里执行，与Activity互不影响。 当用户点击一个按钮时如果执行的是一个常耗时操作的话，处理不好会导致系统假死，用户体验很差，而Android则更进一步，如果任意一个Acitivity没有响应5秒钟以上就会被强制关闭，因此我们需要另外起动一个线程来处理长耗时操作，而主线程则不受其影响，在耗时操作完结发送消息给主线程，主线程再做相应处理。那么线程之间的消息传递和异步处理用的就是Handler。 加群讨论研究 QQ群：56839077

handler只是activity 或 service中的一个消息队列。。。。service只是一个没有界面的activity。。。每个activity和service中只能由一个handler对象

一、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();

new Handler(Looper.getMainLooper())由getMainLooper()可知是获取UI主线程looper,在UI线程中处理消息； Handler handler = new Handler()会默认用当前线程的looper，一般情况是当前线程的异步线程与当前线程进行消息处理。 一般而言new Handler(Looper.getMainLooper())用于更新UI，Handler handler = new Handler()用于当前线程与异步线程的消息处理

在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

至于什么意识，我不知道怎么个回答法。。。。含义就是，实例一个 Handler 类 。私有属性

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

主线程中创建 handlerhandler的引用注入到adapteradapter里通过handler的引用发送message主线程中处理message

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) 方法， 用于接受线程数据。

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

一、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) 子类需要继承Hendler类，并重写handleMessage(Message msg) 方法, 用于接受线程数据以下为一个实例，它实现的功能为 : 通过线程修改界面Button的内容public class MyHandlerActivity extends Activity { 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 catch block 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 } }}

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())。

post类方法允许你排列一个Runnable对象到主线程队列中

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方法。

线程间通信是在Android开发中比较经常遇到的，我们刷新UI界面一般是通过子线程做完某些事情后，要改变主页面就要通过数据的通信，让主线程接收到信息后自己改变UI界面。 1. Handle 先进先出原则； 2. Looper 类用来管理特定线程内对象之间的消息交换(MessageExchange)； 3. Message 类用来保存数据。 1.Looper: 一个线程可以产生一个Looper对象，由它来管理此线程里的MessageQueue(消息队列)； 2.Handler: 你可以构造Handler对象来与Looper沟通，以便push新消息到MessageQueue里;或者接收Looper从Message Queue取出)所送来的消息； android.os.Message的主要功能是进行消息的封装，同时可以指定消息的操作形式，Message类定义的变量和常用方法如下： 在整个消息处理机制中，message又叫task，封装了任务携带的信息和处理该任务的handler。message的用法比较简单，但是有这么几点需要注意： 在使用Handler处理Message时，需要Looper（通道）来完成。在一个Activity中，系统会自动帮用户启动Looper对象，而在一个用户自定义的类中，则需要用户手工调用Looper类中的方法，然后才可以正常启动Looper对象。Looper的字面意思是“循环者”，它被设计用来使一个普通线程变成Looper线程。所谓Looper线程就是循环工作的线程。在程序开发中（尤其是GUI开发中），我们经常会需要一个线程不断循环，一旦有新任务则执行，执行完继续等待下一个任务，这就是Looper线程。使用Looper类创建Looper线程很简单： 这是在子线程中创建Handler的情况，如果在主线程中创建Handler是不需要调用 Looper.prepare(); 和 Looper.loop(); 方法。 Handler是更新UI界面的机制，也是消息处理的机制。我们可以通过Handle发送消息，也可以处理消息。 Android在设计的时候，封装了一套消息创建、传递、处理机制，如果不遵循这样的机制就没有办法更新UI信息，就会抛出异常。 创建Handler实例化对象时，可以重写的回调方法：

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的消息移除。(同步屏障) 更多内容戳这里（整理好的各种文集）

tvb剧集中卧底的上司，英文名字叫handlerhandler是处理者，管理者的意思。如《使徒行者》中卓凯就是卧底们的handler.

handlethebusiness是处理业务的意思operatethebusiness是经营生意，做生意的意思操作一个生意，英语的说法应该等同于operatethebusiness

brave, I tried to go into the water many times, finally I made it

个人感觉treatment多用在处理疾病方面，handling着重手动操作设备方面。