barriers / 阅读 / 详情

android 用handler怎么把消息发送到指定的activity

2023-07-21 17:41:45
共2条回复
S笔记
* 回复内容中包含的链接未经审核,可能存在风险,暂不予完整展示!

1.在MyAPP中定义属性handler

package j***.com;

import j***.com.MasterActivity.MyHandler;

import android.app.Application;

/**

* 自己实现Application,实现数据共享

* @author jason

*/

public class MyAPP extends Application {

// 共享变量

private MyHandler handler = null;

// set方法

public void setHandler(MyHandler handler) {

this.handler = handler;

}

// get方法

public MyHandler getHandler() {

return handler;

}

}

2、在主activity 中给MyAPP的属性handler赋值

@Override

public void onCreate(Bundle savedInstanceState) {

super.onCreate(savedInstanceState);

setContentView(R.layout.main);

mAPP = (MyAPP) getApplication();

handler = new MyHandler();

tv = (TextView) findViewById(R.id.tv);

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

// 设置监听器

btn_to.setOnClickListener(new OnClickListener() {

@Override

public void onClick(View v) {

// 设置共享变量

mAPP.setHandler(handler);

// 启动另一个Activity

Intent intent = new Intent(MasterActivity.this,

ToChangeViewActivity.class);

startActivity(intent);

}

});

}

3、在另一个activity中获取MyAPP中handler进行传值

protected void onCreate(Bundle savedInstanceState) {

super.onCreate(savedInstanceState);

setContentView(R.layout.show);

mAPP = (MyAPP) getApplication();

// 获得该共享变量实例

mHandler = mAPP.getHandler();

findViewById(R.id.btn_chang).setOnClickListener(new OnClickListener() {

@Override

public void onClick(View v) {

// 发送消息

mHandler.sendEmptyMessage(CHANGED);

ToChangeViewActivity.this.finish();

}

});

}

小菜G

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

相关推荐

tvb剧集中卧底的上司,英文名字叫hand什么

tvb剧集中卧底的上司,英文名字叫handlerhandler是处理者,管理者的意思。如《使徒行者》中卓凯就是卧底们的handler.
2023-07-21 15:19:571

Android面试 Handler机制

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的消息移除。(同步屏障) 更多内容戳这里(整理好的各种文集)
2023-07-21 15:20:201

Handler源码分析

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()开启主线程轮训。
2023-07-21 15:20:451

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对象到队列中,等待更新.
2023-07-21 15:20:591

ui中handler有什么作用

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

Android-Handle(线程间通信)详解

线程间通信是在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实例化对象时,可以重写的回调方法:
2023-07-21 15:21:331

handler的特点

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方法。
2023-07-21 15:21:501

能讲讲Android的Handler机制吗

主线程易阻塞,所以创建多线程,由子线程发消息给主线程,由主线程刷新ui
2023-07-21 15:22:101

stm32中断的handler是什么意思

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

在c#程序设计里 Handler 这个词一般会翻译成什么?

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

安卓开发Handler()函数

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+""); }; };
2023-07-21 15:22:321

android handler怎么写

Handler handler1 = new Handler() {@Overridepublic void handleMessage(Message msg) {if (msg.what == 1) {}}};Message message = handler1.obtainMessage();message.what = 1;handler1.sendMessage(message);
2023-07-21 15:22:511

Android中Handler的主要作用是什么?通俗点,初学。

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

Android中Handler的使用方法

不明白··· 还是不明吧
2023-07-21 15:23:126

关于Handler的说法不正确的是

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

怎么创建Handler?

有两种方式:使用默认的构造方法:newHandler()。使用带参的构造方法,参数是一个Runnable对象或者回调对象。
2023-07-21 15:23:351

简要描述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):指定多少毫秒之后发送消息。
2023-07-21 15:24:171

js中总是说的handler是什么意思 还有函数中的event是什么意思

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

如果要对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):指定多少毫秒之后发送消息。
2023-07-21 15:24:431

springmvc中的handler是什么意思

当请求发生时, DispatcherServlet 将请求递交给 hangler mapping, 让其检测请求并提出一个
2023-07-21 15:24:532

android 判断handler是否有消息

用这个方法hasMessages(int what)循环一下private boolean isHandlerMsgEmpty(Handler handler){for(...) { isEmpty = handler.hasMessages(int what);if(!isEmpty )break;}return isEmpty ;}
2023-07-21 15:25:021

handler报错怎么解决

Message message = Message.obtain();new 一个 查看原帖>>
2023-07-21 15:25:352

android中Handler的post方法的作用是什么

post类方法允许你排列一个Runnable对象到主线程队列中
2023-07-21 15:25:444

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())。
2023-07-21 15:26:031

关于handler的说法不正确的是

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

handler可以设置优先级吗

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更新,然后向其发送消息就可以了。
2023-07-21 15:26:181

一个线程有几个handler

我知道你这个他有哪几个shaat第二那这个肯定非常多的那个可能那个他的
2023-07-21 15:26:278

使徒行者里面卓sir说他是卧底的上司兼联络人的英文

handler
2023-07-21 15:26:425

android handler是在主线程中吗

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

Android的handler机制的原理?

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。
2023-07-21 15:27:492

简述android studio中handler通信

  在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的子类。所以说,他俩都算一个进程。
2023-07-21 15:28:051

Android中的Handler详解以及和Thread的区别

一、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 } }}
2023-07-21 15:28:131

Android中的Handler详解以及和Thread的区别

百度一下一大把,不是百度知道几百个字可以说清楚的。
2023-07-21 15:28:392

handler机制是线程安全的吗

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) 方法, 用于接受线程数据。
2023-07-21 15:28:481

android adapter 怎样使用handler

主线程中创建 handlerhandler的引用注入到adapteradapter里通过handler的引用发送message主线程中处理message
2023-07-21 15:28:561

Android中的Handler详解以及和Thread的区别

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

求安卓大神,android中Handler中的obtainMessage()

就是你的Message传给Handler的值,Messagemsg=handler.obtainMessage();msg.arg1=1;msg.arg2=2;msg.what=3;msg.obj=Object;在Handler中接收Handlerhandler=newHandler(){@OverridepublicvoidhandleMessage(Messagemsg){super.handleMessage(msg);//接收Message发送的消息msg.whatmsg.arg1msg.arg2msg.obj//这里msg.obj需要强转成你传过来的数据类型}};
2023-07-21 15:29:121

android的Handler中sendEmptyMessage与sendMessage的区别?

一般来说在工作线程中执行耗时任务,当任务完成时,会返回UI线程,一般是更新UI。这时有两种方法可以达
2023-07-21 15:29:222

android中 private Handler mHandler = new Handler()是什么意识,含义是什么,谢谢啦

至于什么意识,我不知道怎么个回答法。。。。含义就是,实例一个 Handler 类 。私有属性
2023-07-21 15:29:313

Handler 中的 epoll

在 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
2023-07-21 15:29:501

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());懂了吗不懂可以继续提问,嘿嘿 查看原帖>>
2023-07-21 15:30:112

子线程中可以使用Handler吗

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

Android中Handler的运行机制是什么?Handler,Looper,MessageQueue,Message之间的关系是什么?

【答案】:一个Handler允许你发送和处理Message和Runable对象,每个线程都有自己的Looper,每个Looper中封装着MessageQueue。Looper负责不断的从自己的消息队列里取出队头的任务或消息执行。每个handler也和线程关联,Handler负责把Message和Runable对象传递给MessageQueue(用到post ,sendMessage等方法),而且在这些对象离开MessageQueue时,Handler负责执行他们(用到handleMessage方法)。其中Message类就是定义了一个信息,这个信息中包含一个描述符和任意的数据对象,这个信息被用来传递给Handler.Message对象提供额外的两个int域和一个Object域。
2023-07-21 15:30:261

easyui中toolbar的handler 是什么意思

单击事件。
2023-07-21 15:30:352

Android 为什么我Send了一个Message我的Handler没有接受到?如以下代码:

Timer timer = new Timer();TimerTask task = new TimerTask(){Handler handler = new Handler(){public void handleMessage(Message msg){baifenbi.setText(i+"%");if (i == 10 || i == 40 || i == 70){jiazai.setText("正在加载,请稍后.");}if (i == 20 || i == 50 || i == 80){jiazai.setText("正在加载,请稍后..");}if (i == 30 || i == 60 || i == 90){jiazai.setText("正在加载,请稍后...");}}};@Overridepublic void run() {// TODO Auto-generated method stubMessage msg = new Message();msg.what = i;i++;handler.sendMessage(msg);if (i == 100){timer.cancel();Intent a = new Intent();a.setClass(MainActivity.this, Lab.class);startActivity(a);finish();}}};timer.schedule(task, 0,100);
2023-07-21 15:30:432

handler在extjs中起什么作用?

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

handler消息处理机制activity里写什么

在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处理消息时,需要注意线程间的同步和数据安全等问题。
2023-07-21 15:31:221

Handler handler = new Handler()和new Handler(Looper.getMainLooper())的区别

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

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对象到队列中,等待更新.四、应用实例: 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();
2023-07-21 15:31:373

android中handler和service的区别是什么

handler只是activity 或 service中的一个消息队列。。。。service只是一个没有界面的activity。。。每个activity和service中只能由一个handler对象
2023-07-21 15:31:463