android更新ui

⑴ android 怎样发送广播更新ui

更新ui 可以直接在主线程里操作。一般用不到广播。如果非要用广播，一般都是服务更新线程才这么做。在服务里注册/发送广播。然后在ui线程里接受广播,执行更新操作。

⑵ Android UI线程

思考：

先必须了解下面2个问题
1.顾名思义 UI线程 就是刷新UI 所在线程
2.UI是单线程刷新

1.对Activity 来说 UI线程就是其主线程
2.对View来说 UI线程就是创建ViewRootImpl所在的线程
可以通过 WindowManager 内部会创建ViewRootImpl对象

好了，进入主题。我们来慢慢揭开面纱。
我们可以分别从几个方面切入

我们可能都有使用过 runOnUiThread 现在来看看的源码实现。

可以从上面的源码 看到
不是UI线程 就用Handler切到Handler所在的线程中，如果是UI线程直接就调用run方法。

Activity的创建：
1.Activity创建：mInstrumentation.newActivity
2.创建Context ：ContextImpl (r)

我们经常用这个方法干的事情就是，要么在onCreate中获取View宽高的值。要么就是在子线程中做一些耗时操作 ，然后post切到对应View所在的线程 来绘制UI操作。那么这个对应的线程就是UI线程了。
那么这个UI线程就一定是主线程吗？
接来继续来看。它的源码View:post

mAttachInfo 在dispatchAttachedToWindow 中被赋值 ，也就是在ViewRootImpl创建的时候，所以是创建ViewRootImpl所在的线程。
attachInfo 上面时候为null 呢？在ViewRootImpl 还没来得及创建的时候，ViewRootImpl 创建是在 “onResume" 之后。所以在 Activity 的 onCreate 去View.post 那么AttachInfo 是为null 。
当 AttachInfo == null 那么会调用 getRunQueue().post(action) 。
最终这个Runnable 被 缓存到 HandlerActionQueue 中。
直到ViewRootImpl 的 performTraversals 中 调用dispatchAttachedToWindow(mAttachInfo, 0);， 那么才会去处理 RunQueue() 中的Runnable。
来张图 便于理解这个流程

我们有时候去子线程操作UI的时候(如：requestLayout)，会很经常见到下面的 报错日志：
Only the original thread that created a view hierarchy can touch its views

为什么会报这个错误呢？
翻译一下：只有创建视图层次结构的原始线程才能接触到它的视图。
也就是操作UI的线程要和ViewRootImpl创建的线程是同一个线程才行，并不是只有主线程才能更新UI啊。
ViewRootImpl创建的线程？那么 ViewRootImpl 在哪里被创建的呢？

从上图可以看到ViewRootImpl创建最开始是从 ActivityThread 的HandleResumeActivity中开始 一直 ViewRootImpl 创建，也就是说ViewRootImpl 对应的UI线程和 ActivityThread 在同一个线程 也就是主线程。

好了 通过上面的讲解，上面的问题相信你可以自己回答啦~

⑶ android通过Handler使子线程更新UI

在Android项目中经常有碰到这样的问题，在子线程中完成耗时操作之后要更新UI，下面就自己经历的一些项目总结一下更新的方法。

一. 引言

首先来看一下android中消息机制：

专业术语：

Message：消息，其中包含了消息ID，消息处理对象以及处理的数据等，由MessageQueue统一列队，终由Handler处理。
Handler：处理者，负责Message的发送及处理。使用Handler时，需要实现handleMessage(Message msg)方法来对特定的Message进行处理，例如更新UI等。
MessageQueue：消息队列，用来存放Handler发送过来的消息，并按照FIFO规则执行。当然，存放Message并非实际意义的保存，而是将Message以链表的方式串联起来的，等待Looper的抽取。
Looper：消息泵，不断地从MessageQueue中抽取Message执行。因此，一个MessageQueue需要一个Looper。
Thread：线程，负责调度整个消息循环，即消息循环的执行场所。

二. 方法

1. 用Handler

(1)主线程中定义Handler：

java代码：

[java]view plain

HandlermHandler=newHandler(){

@Override

publicvoidhandleMessage(Messagemsg){

super.handleMessage(msg);

switch(msg.what){

case0:

<spanstyle="color:#009900;">//完成主界面更新,拿到数据</span>

Stringdata=(String)msg.obj;

updateWeather();

textView.setText(data);

break;

default:

break;

}

}

};

(2)子线程发消息，通知Handler完成UI更新：

java代码：

privatevoipdateWeather(){

newThread(newRunnable(){

@Override

publicvoidrun(){

<spanstyle="color:#009900;">//耗时操作，完成之后发送消息给Handler，完成UI更新；</span>

mHandler.sendEmptyMessage(0);

<spanstyle="color:#33cc00;">//需要数据传递，用下面方法；</span>

Messagemsg=newMessage();

msg.obj="数据";<spanstyle="color:#33cc00;">//可以是基本类型，可以是对象，可以是List、map等；</span>

mHandler.sendMessage(msg);

}

}).start();

}

注意：Handler对象必须定义在主线程中，如果是多个类直接互相调用，就不是很方便，需要传递content对象或通过接口调用。

2.用Activity对象的runOnUiThread方法更新

在子线程中通过runOnUiThread()方法更新UI：

java代码:

newThread(){

publicvoidrun(){

<spanstyle="color:#009900;">//这儿是耗时操作，完成之后更新UI；</span>

runOnUiThread(newRunnable(){

@Override

publicvoidrun(){

<spanstyle="color:#009900;">//更新UI</span>

imageView.setImageBitmap(bitmap);

}

});

}

}.start();

如果在非上下文类中，可以通过传递上下文实现调用：

java代码：

Activityactivity=(Activity)imageView.getContext();

activity.runOnUiThread(newRunnable(){

@Override

publicvoidrun(){

imageView.setImageBitmap(bitmap);

}

});

注意：这种方法使用比较灵活，但如果Thread定义在其他地方，需要传递Activity对象。

3.
View.post(Runnable r)

java代码：

imageView.post(newRunnable(){

@Override

publicvoidrun(){

imageView.setImageBitmap(bitmap);

}

});

这种方法更简单，但需要传递要更新的View过去。

总结：UI的更新必须在主线程中完成，所以不管上述那种方法，都是将更新UI的消息发送到了主线程的消息对象，让主线程做处理。

⑷ Android——消息分发机制

什么是 Handler 机制 ？
Handler 机制是 Android 中用于 线程间通信 的一套通信机制。

为什么是 Handler ？Handler 机制为什么被那么多次的提及 ？
从Android4.0开始，Android 中网络请求强制不允许在主线程中操作，而更新UI的操作则不允许在子线程中执行。当在子线程中执行网络请求，拿到服务器返回的数据之后，要更新UI。由于系统的要求，势必会产生一种矛盾：数据在子线程，更新UI要在主线程。此时我们必须要把数据返回到主线程中才行，Handler机制应运而生。

Android 中针对耗时的操作，放在主线程操作，轻者会造成 UI 卡顿，重则会直接无响应，造成 Force Close。同时在 Android 3.0 以后，禁止在主线程进行网络请求。

针对耗时或者网络操作，那就不能在主线程进行直接操作了，需要放在子线程或者是工作线程中进行操作，操作完成以后，再更新主线程即 UI 线程。这里就涉及到一个问题了，在子线程执行完成以后，怎么能更新到主线程即 UI 线程呢，针对以上问题，就需要用到 Android 的消息机制了，即： Handler, Message, MessageQueue, Looper 全家桶

Handler机制中最重要的四个对象

Handler的构造方法:

Looper :

Handler的使用：

MessageQueue：

Looper.loop()

Handler.dispatchMessage()

handler导致activity内存泄露的原因：
handler发送的消息在当前handler的消息队列中，如果此时activity finish掉了，那么消息队列的消息依旧会由handler进行处理，若此时handler声明为内部类（非静态内部类），我们知道内部类天然持有外部类的实例引用，这样在GC垃圾回收机制进行回收时发现这个Activity居然还有其他引用存在，因而就不会去回收这个Activity，进而导致activity泄露。

假如在子线程执行了耗时操作，这时用户操作进入了其他的 acitvity， 那么 MainActivity 就会被内存回收的，但是这个时候发现 Handler 还在引用着 MainActivity，内存无法及时回收，造成内存泄漏。

Handler 防止内存泄漏常见方法：

为什么通过 Handler 可以把子线程的结果通知或者携带给 UI 线程 ？
这里的 Handler 指的是主线程的 Handler ,同时与 Handler 配套的 Looper ， MessageQueue 是在 UI 线程初始化的，所以在子线程中调用 Handler 发送消息可以更新 UI 线程。
Looper 在 UI 线程源码, 在 ActivityThread 类：

⑸ android中如何实现UI的实时更新

1、在主线程中启动一个子线程

首先，我们需要在主线程中启动一个子线程，这个比较简单，直接在MainActivity的onCreate()方法中调用如下方法即可：

newThread(mRunnable).start();

2、在子线程中发送Message给Handler

在创建子线程时，我们使用了Runnable接口对象mRunnable。这里，只需要实现Runnable接口，并重写该接口的run()方法，在run()方法中实现每1秒发送一条Message给Handler即可。具体实现方法如下：

/*
*Function:实现run()方法，每1秒发送一条Message给Handler
*/
privateRunnablemRunnable=newRunnable(){
publicvoidrun(){
while(true){
try{
Thread.sleep(1000);
mHandler.sendMessage(mHandler.obtainMessage());
}catch(InterruptedExceptione){
e.printStackTrace();
}
}
}
};

3、Handler接收Message通知

最后，我们创建一个Handler对象，用来接收Message通知。在收到Message通知后，完成刷新UI的操作即可。具体实现方法如下：

/*
*Function:实现handleMessage()方法，用于接收Message，刷新UI
*/
privateHandlermHandler=newHandler(){
publicvoidhandleMessage(Messagemsg){
super.handleMessage(msg);
refreshUI();
}
};

4、刷新UI

由以上的代码可以看出，刷新UI的操作，我们是放在refreshUI()方法中来完成的。refreshUI()方法的实现也很简单，调用HttpUtils工具类中的getInputStream()方法，获得图1所示Web工程的页面内容输入流，再将该输入流转化为字符串，放入TextView控件中进行显示即可。具体实现方法如下：

/*
*Function:刷新UI
*/
privatevoidrefreshUI(){
try{
InputStreaminputStream=HttpUtils.getInputStream();
StringresultData=HttpUtils.getResultData(inputStream);
mTextView.setText(resultData);
}catch(IOExceptione){
e.printStackTrace();
}
}

⑹ 如何在Android开发中用AsyncTask异步更新UI界面

1
本次的异步处理的一种方式AsyncTask，其实它的本质是一个线程池，所有提交的异步任务都会在这个线程池中的工作线程内执行，当工作线程需要跟UI线程交互时，工作线程会通过向在UI线程创建的Handler传递消息的方式，调用相关的回调函数，从而实现UI界面的更新。

2
AsyncTask抽象出后台线程运行的五个状态，分别是：1、准备运行，2、正在后台运行，3、进度更新，4、完成后台任务，5、取消任务，对于这五个阶段，AsyncTask提供了五个回调函数：其中，准备运行：onPreExecute(),该回调函数在任务被执行之后立即由UI线程调用。这个步骤通常用来建立任务，在用户接口（UI）上显示进度条；

3
doInBackground(Params...),该回调函数由后台线程在onPreExecute()方法执行结束后立即调用。通常在这里执行耗时的后台计算。计算的结果必须由该函数返回，并被传递到onPostExecute()中。在该函数内也可以使用publishProgress(Progress...)来发布一个或多个进度单位(unitsof progr ess)。这些值将会在onProgressUpdate(Progress...)中被发布到UI线程；

4
完成后台任务：onPostExecute(Result),当后台计算结束后调用。后台计算的结果会被作为参数传递给这一函数；

5
最后在程序中启动该异步代码；

⑺ android怎么更新UI

首先，android的UI刷新是在主线程（UI线程）中完成的。四大组件中，activity和service运行在主线程中。现在总结自己在项目中常用到的UI刷新方式。
第一，利用子线程发消息刷新UI。
子线程负责处理UI需要的数据，然后发消息到主线程来刷新UI。代码结构如下：
new Thread(new Runnable() {

@Override
public void run() {
Person person=new Person();
person.setName(mName.getText().toString().trim());
person.setPhone(mPhone.getText().toString().trim());
Log.i("person",person.toString());
DatabaseInfoFactory.getPersonDao(mContext).addPerson(person);
Looper.prepare();
Message msg=Message.obtain();
msg.what=0x123456;
handler.sendMessage(msg);
Looper.loop();

}
}).start();
主线程中：
private Handler mHandler=new Handler(){

@Override
public void handleMessage(Message msg) {
// TODO Auto-generated method stub
super.handleMessage(msg);
if(msg.what==0x123456||msg.what==0x123){
fillData();
setListener();
}

}
};
第二，利用异步任务更新UI。代码结构如下：
new AsyncTask<void,void,void>() {

@Override
protected void onPostExecute(Void result) {

if(mAdapter==null){
mAdapter=new LeaveInfoAdapter();
//设置数据适配器
mLVleaveInfos.setAdapter(mAdapter);
Log.i("测试", "异步任务显示后台获得数据库数据");
}
else {
mAdapter.notifyDataSetChanged();

}

super.onPostExecute(result);
}

@Override
protected Void doInBackground(Void... params) {
//获得要显示的数据
mleaveInfos=mLeaveInfosDao.findAll();
if (mleaveInfos==null) {
Toast.makeText(HomeActivity.this,"请假数据不存在或是已经清除！", 500).show();

}

Log.i("测试", "异步任务后台获得数据库数据"+mleaveInfos.size());

return null;
}
}.execute();</void,void,void>
第三，利用配置文件+activity的生命周期方法刷新UI。

⑻ Android service 可以直接更新UI吗

就算是在Activity的开启的新线程中也是无法直接更新UI的，若这样做会导致应用崩溃，Android限制要求在UI线程中即主线程中才能更新UI，这样做的目的是为了防止多线程同时修改同一个控件导致各种问题的产生，若要在其他新建的线程中更新UI需要借助API中提供的handler。

原理大致为在主线程中实现处理特定消息的接口，然后在其他地方使用handler发送自己定义的消息，当主线程接收到消息后，你就可以根据消息的内容更新UI了。

当然也有特例，如SurfaceView就支持在新线程中修改UI。service属于后台与Avtivity属于不同的组件，运行在不同的线程下，它的设计不是为了处理界面的，所以不建议这么做。

下面是几个可行的方法：

1. 通过广播，即在 Activity中注册一个广播，然后通过广播进行service和Activity间的数据传递，同时以达到更新UI的目的。

2. 通过继承Binder类和一个回调方法实现对view的更新。当然如果不要回调方法也可以，那就直接在handleMessage（）中进行数据更新也是可以。

⑼ Android 在子线程中更新UI的几种方法示例

请您慢慢看：

直接在UI线程中开启子线程来更新TextView显示的内容，运行程序我们会发现，如下错误：android.view.ViewRoot$: Only the original thread that created a view hierarchy can touch its views.翻译过来就是：只有创建这个控件的线程才能去更新该控件的内容。

所有的UI线程要去负责View的创建并且维护它，例如更新冒个TextView的显示，都必须在主线程中去做，我们不能直接在UI线程中去创建子线程，要利用消息机制：handler，如下就是handler的简单工作原理图：

既然android给我们提供了Handler机制来解决这样的问题，请看如下代码：

public class HandlerTestActivity extends Activity { private TextView tv; private static final int UPDATE = 0; private Handler handler = new Handler() { @Overridepublic void handleMessage(Message msg) { // TODO 接收消息并且去更新UI线程上的控件内容if (msg.what == UPDATE) { // Bundle b = msg.getData();// tv.setText(b.getString("num")); tv.setText(String.valueOf(msg.obj)); } super.handleMessage(msg); } }; /** Called when the activity is first created. */@Overridepublic void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.main); tv = (TextView) findViewById(R.id.tv); new Thread() { @Overridepublic void run() { // TODO 子线程中通过handler发送消息给handler接收，由handler去更新TextView的值try { for (int i = 0; i < 100; i++) { Thread.sleep(500); Message msg = new Message(); msg.what = UPDATE; // Bundle b = new Bundle();// b.putString("num", "更新后的值：" + i);// msg.setData(b); msg.obj = "更新后的值：" + i; handler.sendMessage(msg); } } catch (InterruptedException e) { e.printStackTrace(); } } }.start(); }}

我们就通过Handler机制来处理了子线程去更新UI线程控件问题，Andrid开发中要经常用到这种机制。