利用VIEW中的POST处理UI卡住的问题【aide吧】_百度贴吧
&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&签到排名：今日本吧第个签到，本吧因你更精彩，明天继续来努力！
本吧签到人数：0成为超级会员，使用一键签到本月漏签0次！成为超级会员，赠送8张补签卡连续签到：天&&累计签到：天超级会员单次开通12个月以上，赠送连续签到卡3张
关注：26,698贴子：
利用VIEW中的POST处理UI卡住的问题收藏
eee.post(new Runnable()//这里用的是view的post方法{//这里的内容将在主线程中显示
public void run(){}});
有的时候连接网络或者遍历数据，都会导致UI的某种原因提示用户关闭程序，造成用户体验不足，原因程序事件5-10秒没有反应过来，或者没有反应，就会导致UI的[X][X]，所以很多人利用多线程，也有人利用这个方法，这个我觉得比线程，好理解
所以就完美处理耗时操作了，，，
你这个方法还是一个线程中，你把线程名字输出来就知道了。
……投机取巧，不建议
我原来发的那个摇你妹源码里面有线程启动方法，实现Runnable接口，然后使用new Thread(this).start()方法就是启动一个线程，线程函数是run函数。
登录百度帐号推荐应用android中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对象到队列中，等待更新.
四、应用实例：
在Android中，对于UI的操作通常需要放在主线程中进行操作。如果在子线程中有关于UI的操作，那么就需要把数据消息作为一个Message对象发送到消息队列中，然后，用Handler中的handlerMessge方法处理传过来的数据信息，并操作UI。类sendMessage(Message msg)方法实现发送消息的操作。
在初始化Handler对象时重写的handleMessage方法来接收Messgae并进行相关操作。
Handler对象在进行初始化的时候，会默认的自动绑定消息队列。利用类post方法，可以将Runnable对象发送到消息队列中，按照队列的机制按顺序执行不同的Runnable对象中的run方法。
另外，Android的CPU分配的最小单元是线程，Handler一般是在某个线程里创建的，因而Handler和Thread就是相互绑定的，一一对应。而Runnable是一个接口，Thread是Runnable的子类。所以说，他俩都算一个进程。
&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
&视频教程中的例子：
public&class&HandlerActivity&extends&Activity&{
&&&&//声明两个按钮控件
&&&&private&Button&startButton&=&
&&&&private&Button&endButton&=&
&&&&@Override&
&&&&public&void&onCreate(Bundle&savedInstanceState)&{
&&&&&&&&super.onCreate(savedInstanceState);
&&&&&&&&setContentView(R.layout.main);
&&&&&&&&//根据控件的ID得到代表控件的对象，并为这两个按钮设置相应的监听器
&&&&&&&&startButton&=&(Button)findViewById(R.id.startButton);
&&&&&&&&startButton.setOnClickListener(new&StartButtonListener());
&&&&&&&&endButton&=&(Button)findViewById(R.id.endButton);
&&&&&&&&endButton.setOnClickListener(new&EndButtonListener());
&&&&class&StartButtonListener&implements&OnClickListener{
&&&&&&&&@Override&
&&&&&&&&public&void&onClick(View&v)&{
&&&&&&&&&&&&//调用Handler的post方法，将要执行的线程对象添加到队列当中
&&&&&&&&&&&&handler.post(updateThread);
&&&&class&EndButtonListener&implements&OnClickListener{
&&&&&&&&@Override&
&&&&&&&&public&void&onClick(View&v)&{
&&&&&&&&&&&&handler.removeCallbacks(updateThread);
&&&&//创建一个Handler对象
&&&&Handler&handler&&=&new&Handler();
&&&&//将要执行的操作写在线程对象的run方法当中
&&&&Runnable&updateThread&=&&new&Runnable(){
&&&&&&&&@Override&
&&&&&&&&public&void&run()&{
&&&&&&&&&&&&System.out.println("UpdateThread");
&&&&&&&&&&&&//在run方法内部，执行postDelayed或者是post方法
&&&&&&&&&&&&handler.postDelayed(updateThread,&3000);
程序的运行结果就是每隔3秒钟，就会在控制台打印一行UpdateTread。这是因为实现了Runnable接口的updateThread对象进入了空的消息队列即被立即执行run方法，而在run方法的内部，又在3000ms之后将其再次发送进入消息队列中。
Handler和多线程
post方法虽然发送的是一个实现了Runnable接口的类对象，但是它并非创建了一个新线程，而是执行了该对象中的run方法。也就是说，整个run中的操作和主线程处于同一个线程。
这样对于那些简单的操作，似乎并不会影响。但是对于耗时较长的操作，就会出现“假死”。为了解决这个问题，就需要使得handler绑定到一个新开启线程的消息队列上，在这个处于另外线程的上的消息队列中处理传过来的Runnable对象和消息。&
public&class&HandlerTest2&extends&Activity&{
&&&&@Override&
&&&&protected&void&onCreate(Bundle&savedInstanceState)&{
&&&&&&&&//&TODO&Auto-generated&method&stub
&&&&super.onCreate(savedInstanceState);
&&&&setContentView(R.layout.main);
&&&&//打印了当前线程的ID &
&&&&System.out.println("Activity--&"&+&Thread.currentThread().getId());
&&&&//生成一个HandlerThread对象
&&&&HandlerThread&handlerThread&=&new&HandlerThread("handler_thread");
&&&&//在使用HandlerThread的getLooper()方法之前，必须先调用该类的start()，同时开启一个新线程; &
&&&&handlerThread.start();
&&&&//将由HandlerThread获取的Looper传递给Handler对象，即由处于另外线程的Looper代替handler初始化时默认绑定的消息队列来处理消息。
&&&&&// HandlerThread顾名思义就是可以处理消息循环的线程，它是一个拥有Looper的线程
，可以处理消息循环；&
其实与其说Handler和一个线程绑定，倒不如说Handler和Looper是
一一对应的。
&&&&MyHandler&myHandler&=&new&MyHandler(handlerThread.getLooper());
&&&&Message&msg&=&myHandler.obtainMessage();
&&&&//将msg发送到目标对象，所谓的目标对象，就是生成该msg对象的handler对象
&&&&Bundle&b&=&new&Bundle();
&&&&b.putInt("age",&20);
&&&&b.putString("name",&"Jhon");
&&&&msg.setData(b);
&&&&msg.sendToTarget();
&//将msg发送到myHandler
&&&&//定义类
&&&&class&MyHandler&extends&Handler{
&&&&public&MyHandler(){
&&&&&&&&&&&&
&&&&public&MyHandler(Looper&looper){
&&&&&&&&super(looper);
&&&&@Override&
&&&&public&void&handleMessage(Message&msg)&{
&&&&&&&&Bundle&b&=&msg.getData();
&&&&&&&&int&age&=&b.getInt("age");
&&&&&&&&String&name&=&b.getString("name");
&&&&&&&&System.out.println("age&is&"&+&age&+&",&name&is"&+&name);
&&&&&&&&System.out.println("Handler---&"&+&Thread.currentThread().getId());
&&&&&&&&System.out.println("handlerMessage");
这样，当使用sendMessage方法传递消息或者使用post方法传递Runnable对象时，就会把它们传递到与handler对象绑定的处于另外一个线程的消息队列中，它们将在另外的消息队列中被处理。而主线程还会在发送操作完成时候继续进行，不会影响当前的操作。
这里需要注意，这里用到的多线程并非由Runnable对象开启的，而是ThreadHandler对象开启的。Runnable对象只是作为一个封装了操作的对象被传递，并未产生新线程。
另外再强调一遍，在UI线程（主线程）中：
mHandler=new Handler();
&&&&mHandler.post(new
Runnable(){
//执行代码..
这个线程其实是在UI线程之内运行的，并没有新建线程。
常见的新建线程的方法是：
Thread thread = new Thread();
thread.start();
HandlerThread thread = new HandlerThread("string");
thread.start();
已投稿到：
以上网友发言只代表其个人观点，不代表新浪网的观点或立场。一个关于Android程序退出后，线程停止的问题 - ITeye问答
在Android的程序中，UI线程是主线程
理论上来讲，Activity调用了finish方法后，主线程就终止了
那么其上的子线程也应该是停止
但是通过测试，发现并不是这样
finish退出程序后，子线程还在后台跑
必须用DDMS停止该线程才行
那么如何在程序退出时，停止所有开启的子线程呢？
我想到了两个方案：
一，在退出时，改变线程内循环的标识符
while(isRun){...}
将isRun置为false，则打破了循环，线程终止
二，不采用while(isRun){...}这样的循环方式
而利用Android提供的Handler机制来完成
//将一个线程立即加入线程队列，并执行它的[color=red]run[/color]方法
handler.post(test);
Runnable test = new Runnable(){
public void run(){
//以上代码略
//延迟1000毫秒，执行这个线程的[color=red]run[/color]方法
handler.postDelayed(test,1000);
//即从线程队列中移除该线程，不再被执行
handler.removeCallbacks(test);
如红字标注，确实是调用的run方法，所以其实并未真正的启动一个子线程
以上是我想到的两个方案，不知对不对
请大家来探讨一下问题补充原来我的理解不对
楼上兄台能否指点一二
在下感激不尽问题补充原来如此
谢谢指教
system.exit(0),这个应该可以
可以用HandlerThread，将它的Looper给handler就可以，具体用法如下：
HandlerThread handlerThread=new HandlerThread("threadTag");
handlerThread.start();
Handler handler=new Handler(handlerThread.getLooper());
handler.post(test);
这样test不会阻塞ui线程
在activity的onDestroy()方法中handler.removeCallbacks(test)
这个问题也一直困扰着我，也一直没有找到解决的办法。结果，只能用线程池来解决。不知道那位高手有好的方法，不吝赐教。
调用android.os.Process.killProcess(android.os.Process.myPid())这个会杀死进程！
activity finish之后，子线程还是会运行，除非你在destory是显示将标志位置为false,还有一种情况，当系统内存吃紧，系统回收掉你的线程。
系统已经很好的封装了一些类，是你没有太注意吧。
HandlerThread
Looper.myLooper().quit()
Thread.join()
自己去查查，就能解决线程的安全退出。
当然，某个耗时的任务，还是得用标志之类的办法让他中途停下来。
finish 系统并不回收该进程...附带线程没被回收.
等系统需要资源再进行关闭.
也会跟着被回收.
引用Activity调用了finish方法后，主线程就终止了
这个说法是不对的。
引用那么其上的子线程也应该是停止
这个说法也不对。即使主线程终止,非deamon的子线程也不会终止。
已解决问题
未解决问题Android中的Handler的机制与用法详解
Android中的Handler的机制与用法详解，什么是Handler，如何传递 Message，传递 Runnable 对象，传递 Callback 对象，Handler 原理是什么?Handler 与 Looper、MessageQueue 的关系，HandlerThread是什么?Android 中更新 UI 的几种方式。
1. 了解几个概念
很多Android初学者对Android 中的Handler不是很明白，其实Google参考了Windows的消息处理机制，在Android系统中实现了一套类似的消息处理机制。
在下面介绍Handler机制前，首先得了解以下几个概念：
Message 消息，理解为线程间通讯的数据单元。例如后台线程在处理数据完毕后需要更新UI，则可发送一条包含更新信息的Message给UI线程。
Message Queue 消息队列，用来存放通过Handler发布的消息，按照先进先出执行。
Handler Handler是Message的主要处理者，负责将Message添加到消息队列以及对消息队列中的Message进行处理。
Looper 循环器，扮演Message Queue和Handler之间桥梁的角色，循环取出Message Queue里面的Message，并交付给相应的Handler进行处理。
线程 UI thread 通常就是main thread，而Android启动程序时会替它建立一个Message Queue。每一个线程里可含有一个Looper对象以及一个MessageQueue数据结构。在你的应用程序里，可以定义Handler的子类别来接收Looper所送出的消息。
2. 什么是Handler
Handler 是 Android 给我们提供来更新 UI 的一套机制，也是一套消息处理的机制，我们可以发送消息，也可以通过它来处理消息，Handler 在我们的 framework 中是非常常见的。
Android 在设计的时候，就封装了一套消息创建、传递、处理机制，如果不遵循这样的机制就没有办法更新 UI 信息，就会抛出异常信息。
3. Handler 用法
3.1 传递 Message
用于接受子线程发送的数据，并用此数据配合主线程更新 UI。有以下方法：
post(Ruannable);
postAtTime(Runnable, long);
postDelayed(Runnable long);
post类方法允许你排列一个 Runnable 对象到主线程队列中。
3.2 传递 Runnable 对象
用于通过 Handler 绑定的消息队列，安排不同操作的执行顺序，主要有以下方法：
sendEmptyMessage(int);
sendMessage(Message);
sendMessageAtTime(Message, long);
sendMessageDelayed(Message, long);
sendMessage 类方法，允许你安排一个带数据的 Message 对象到队列中，等待更新。
使用 Handler 在子线程中向 UI 线程发送一个消息进行 UI 的更新
创建一个 Message, Message msg = new Message(); msg.arg1 = 88;
handler.sendMessage(msg); msg.obj = 可以传递一个对象
当然不一定要用 new 一个 Message，也可以复用系统的 message 对象 Message msg = handler.obtainMessage();
3.3 传递 Callback 对象
Callback 用于截获 handler 发送的消息，如果返回 true 就截获成功不会向下传递了。
public Handler mHandler = new Handler(new Handler.Callback() {
public boolean handleMessage(Message msg) {
// TODO Auto-generated method stub
Toast.makeText(getApplicationContext(), "HandleMessage 1", Toast.LENGTH_SHORT).show();
public void handleMessage(Message msg) {
// TODO Auto-generated method stub
Toast.makeText(getApplicationContext(), "handleMessage 1", Toast.LENGTH_SHORT).show();
上面的示例中，第一个有返回值的 handlerMessage 方法是 Callback 的回调，如果返回true，则不执行下面的 handlerMessage 方法，从而达到拦截 handler 发送的消息的目的，如果返回 false，则会继续执行 handlerMessage 方法。
4. Handler 原理
4.1 Android 为什么要设计只能通过 Handler 机制更新 UI 呢?
最根本的目的就是解决多线程并发的问题，假设在一个 Activity 当中，有多个线程去更新 UI，并且对更新的 UI 的操作进行枷锁处理的话又会产生什么样的问题呢? 那就是性能下降，Handler 通过消息队列，保证了消息处理的先后有序。
鉴于以上问题的考虑，Android 给我们提供了一套更新 UI 的机制，我们只要使用一套机制就好，所有的更新 UI 的操作都是在主线程中轮询处理。
4.2 Handler 的原理是什么?
Handler 封装了消息的发送(主要包括消息发送给谁) Looper:
内部包含一个消息队列也就是 MessageQueue，所有 Handler 发送的消息都走向这个队列。
Looper.loop()方法，就是一个 for 死循环，不断的从 MessageQueue 取消息，如果有消息就处理消息，没有消息就阻塞。
MessageQueue，就是一个消息队列，可以添加消息，处理消息。
Handler 也不难，比较简单，在构造 Handler 时候内部会跟 Looper 进行关联，通过 Looper.myLooper() 获取到 Looper，找到 Looper 也就找到了 MessageQueue。在 Handler 中发送消息，其实是向 MessageQueue 队列中发送消息。
4.3 Handler 与 Looper、MessageQueue 的关系
这一小结：handler 负责发送消息，Looper 负责接收 Handler 发送消息，并直接把消息回传给 handler 自己，MessageQueue 就是一个存储消息的容器。
如上图所示，一个线程中只有一个 Looper 实例，一个 MessageQueue 实例，可以有多个 Handler 实例。
下图展示了 Handler、MessageQueue、Looper 之间是如何协作的。
下图是一个“我要上厕所”的形象图解：
5. Handler 与子线程
5.1 自定义与线程相关的 Handler
class MyThread extends Thread {
public void run() {
Looper.prepare(); //new 一个Looper对象
handler = new Handler() { //拿到当前线程的 Looper 对象
public void handlerMessage(Message msg) {
// TODO Auto-generated method stub
System.out.println("current thread:" + Thread.currentThread());
Looper.loop();//开始死循环处理消息
一般 UI 主线程中不要执行一些耗时的操作，这样就可以通过子线程消息来处理耗时操作。
5.2 HandlerThread是什么?
HandlerThread 继承于 Thread，所以它本质就是个 Thread。与普通的 Thread 的差别就在于，它有个 Looper 成员变量。这个 Looper 其实就是对消息队列以及队列处理逻辑的封装，简单来说就是消息队列+消息循环。
当我们需要一个工作线程，而不是把它当作一次性消耗品，用过即废的话，就可以使用它。
private Handler mHandler =
private HandlerThread mHandlerThread =
private void sendRunnableToWorker(Ruannable run) {
if (null == mHandlerThread) {
mHandlerThread = new HandlerThread("WorkerThread");
// 给工作者线程低优先级
mHandlerThread.setPriority(Thread.MIN_PRIORITY);
mHandlerThread.start();
if (null == mHandler) {
mHandler = new Handler(mHandlerThread.getLooper());
mHandler.post(run);
6. 主线程与子线程之间的信息交互
//创建主线程的Handler
private Handler mHandler = new Handler() {
public void handleMessage(Message msg) {
Message mssage = new Message();
System.out.println("main Handler");
//向子线程发送消息
threadHandler.sendMessageDelayed(message, 1000);
//创建子线程的 handler
private Handler threadH
protected void onCreate(Bundle saveInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
HandlerThread thread = new HandlerThread("handlerThread");
//创建子线程的 handler
threadHandler = new Handler(thread.getLooper()) {
public void handlerMessage(Message msg) {
Message message = new Message();
//向主线程发送消息
mHandler.sendMessageDelayed(message, 1000);
7. Android 中更新 UI 的几种方式
Android 中更新 UI 的 4 种方式：
runOnUiThread
handler 的 post
handler 的 sendMessage
View 自身的 post
转载自51it技术博客：
相关IT文章}