Android非UI线程更新UI

㈠ 为什么loop之后就可以子线程更新ui

我们常常听到这么一句话：更新UI要在UI线程（或者说主线程）中去更新，不要在子线程中更新UI，而android官方也建议我们不要在非UI线程直接更新UI。

事实是不是如此呢，做一个实验：

更新之前：

代码：

package com.bourne.android_common.ServiceDemo;

import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.widget.TextView;
import com.bourne.android_common.R;

public class ThreadActivity extends AppCompatActivity {

private Thread thread;
private TextView textView;

@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_thread);
textView = (TextView) findViewById(R.id.textView);

thread = new Thread(new Runnable() {
@Override
public void run() {
textView.setText("text text text");
}
});

thread.start();
}

@Override
protected void onDestroy() {
super.onDestroy();
}
}
登录后复制

这里在Activity里面新建了一个子线程去更新UI，按理说会报错啊，可是执行结果是并没有报错，如图所示：

接下来让线程休眠一下：

package com.bourne.android_common.ServiceDemo;

import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.widget.TextView;

import com.bourne.android_common.R;

public class ThreadActivity extends AppCompatActivity {

private Thread thread;
private TextView textView;

@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_thread);
textView = (TextView) findViewById(R.id.textView);

thread = new Thread(new Runnable() {
@Override
public void run() {

try {
Thread.sleep(200);
} catch (InterruptedException e) {
e.printStackTrace();
}

textView.setText("text text text");
}
});

thread.start();
}

}
登录后复制

应用报错，抛出异常：

android.view.ViewRootImpl$: Only the original thread that created a view hierarchy can touch its views

只有创建View层次结构的线程才能修改View，我们在非UI主线程里面更新了View，所以会报错

因为在OnCreate里面睡眠了一下才报错，这是为什么呢？

Android通过检查我们当前的线程是否为UI线程从而抛出一个自定义的AndroidRuntimeException来提醒我们“Only the original thread that created a view hierarchy can touch its views”并强制终止程序运行，具体的实现在ViewRootImpl类的checkThread方法中：

@SuppressWarnings({"EmptyCatchBlock", "PointlessBooleanExpression"})
public final class ViewRootImpl implements ViewParent,
View.AttachInfo.Callbacks, HardwareRenderer.HardwareDrawCallbacks {
// 省去海量代码…………………………

void checkThread() {
if (mThread != Thread.currentThread()) {
throw new (
"Only the original thread that created a view hierarchy can touch its views.");
}
}

// 省去巨量代码……………………
}
登录后复制

这就是Android在4.0后对我们做出的一个限制。

其实造成这个现象的根本原因是：

还没有到执行checkThread方法去检查我们的当前线程那一步。”Android对UI事件的处理需要依赖于Message Queue，当一个Msg被压入MQ到处理这个过程并非立即的，它需要一段事件，我们在线程中通过Thread.sleep(200)在等，在等什么呢？在等ViewRootImpl的实例对象被创建。”

ViewRootImpl的实例对象是在OnResume中创建的啊！

看onResume方法的调度，其在ActivityThread中通过handleResumeActivity调度：

public final class ActivityThread {
// 省去海量代码…………………………

final void handleResumeActivity(IBinder token, boolean clearHide, boolean isForward,
boolean reallyResume) {
unscheleGcIdler();

ActivityClientRecord r = performResumeActivity(token, clearHide);

if (r != null) {
final Activity a = r.activity;

// 省去无关代码…………

final int forwardBit = isForward ?
WindowManager.LayoutParams.SOFT_INPUT_IS_FORWARD_NAVIGATION : 0;

boolean willBeVisible = !a.mStartedActivity;
if (!willBeVisible) {
try {
willBeVisible = ActivityManagerNative.getDefault().willActivityBeVisible(
a.getActivityToken());
} catch (RemoteException e) {
}
}
if (r.window == null && !a.mFinished && willBeVisible) {
r.window = r.activity.getWindow();
View decor = r.window.getDecorView();
decor.setVisibility(View.INVISIBLE);
ViewManager wm = a.getWindowManager();
WindowManager.LayoutParams l = r.window.getAttributes();
a.mDecor = decor;
l.type = WindowManager.LayoutParams.TYPE_BASE_APPLICATION;
l.softInputMode |= forwardBit;
if (a.mVisibleFromClient) {
a.mWindowAdded = true;
wm.addView(decor, l);
}

} else if (!willBeVisible) {
// 省去无关代码…………

r.hideForNow = true;
}

cleanUpPendingRemoveWindows(r);

if (!r.activity.mFinished && willBeVisible
&& r.activity.mDecor != null && !r.hideForNow) {
if (r.newConfig != null) {
// 省去无关代码…………

performConfigurationChanged(r.activity, r.newConfig);
freeTextLayoutCachesIfNeeded(r.activity.mCurrentConfig.diff(r.newConfig));
r.newConfig = null;
}

// 省去无关代码…………

WindowManager.LayoutParams l = r.window.getAttributes();
if ((l.softInputMode
& WindowManager.LayoutParams.SOFT_INPUT_IS_FORWARD_NAVIGATION)
!= forwardBit) {
l.softInputMode = (l.softInputMode
& (~WindowManager.LayoutParams.SOFT_INPUT_IS_FORWARD_NAVIGATION))
| forwardBit;
if (r.activity.mVisibleFromClient) {
ViewManager wm = a.getWindowManager();
View decor = r.window.getDecorView();
wm.updateViewLayout(decor, l);
}
}
r.activity.mVisibleFromServer = true;
mNumVisibleActivities++;
if (r.activity.mVisibleFromClient) {
r.activity.makeVisible();
}
}

if (!r.onlyLocalRequest) {
r.nextIdle = mNewActivities;
mNewActivities = r;

// 省去无关代码…………

Looper.myQueue().addIdleHandler(new Idler());
}
r.onlyLocalRequest = false;

// 省去与ActivityManager的通信处理

} else {
// 省略异常发生时对Activity的处理逻辑
}
}

// 省去巨量代码……………………
}
登录后复制

handleResumeActivity方法逻辑相对要复杂一些，除了对当前显示Window的逻辑判断以及没创建的初始化等等工作外其在最终会调用Activity的makeVisible方法

public class Activity extends ContextThemeWrapper
implements LayoutInflater.Factory2,
Window.Callback, KeyEvent.Callback,
OnCreateContextMenuListener, ComponentCallbacks2 {
// 省去海量代码…………………………

void makeVisible() {
if (!mWindowAdded) {
ViewManager wm = getWindowManager();
wm.addView(mDecor, getWindow().getAttributes());
mWindowAdded = true;
}
mDecor.setVisibility(View.VISIBLE);
}

// 省去巨量代码……………………
}
登录后复制

在makeVisible方法中逻辑相当简单，获取一个窗口管理器对象并将根视图DecorView添加到其中，addView的具体实现在WindowManagerGlobal中：

public final class WindowManagerGlobal {
public void addView(View view, ViewGroup.LayoutParams params,
Display display, Window parentWindow) {
// 省去很多代码

ViewRootImpl root;

// 省去一行代码

synchronized (mLock) {
// 省去无关代码

root = new ViewRootImpl(view.getContext(), display);

// 省去一行代码

// 省去一行代码

mRoots.add(root);

// 省去一行代码
}

// 省去部分代码
}
}
登录后复制

在addView生成了一个ViewRootImpl对象并将其保存在了mRoots数组中，每当我们addView一次，就会生成一个ViewRootImpl对象，其实看到这里我们还可以扩展一下问题一个APP是否可以拥有多个根视图呢？答案是肯定的，因为只要我调用了addView方法，我们传入的View参数就可以被认为是一个根视图，但是！在framework的默认实现中有且仅有一个根视图，那就是我们上面makeVisible方法中addView进去的DecorView，所以为什么我们可以说一个APP虽然可以有多个Activity，但是每个Activity只会有一个Window一个DecorView一个ViewRootImpl，看到这里很多童鞋依然会问，也就是说在onResume方法被执行后我们的ViewRootImpl才会被生成对吧，但是为什么下面的代码依然可以正确运行呢：

package com.bourne.android_common.ServiceDemo;

import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.widget.TextView;

import com.bourne.android_common.R;

public class ThreadActivity extends AppCompatActivity {

private Thread thread;
private TextView textView;

@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_thread);
textView = (TextView) findViewById(R.id.textView);

thread = new Thread(new Runnable() {
@Override
public void run() {
textView.setText("text text text");

}
});

thread.start();
}

@Override
protected void onResume() {
super.onResume();
}
}
登录后复制

Activity.onResume前，ViewRootImpl实例没有建立，所以没有checkThread检查。但是使用了Thread.sleep(200)的时候，ViewRootImpl已经被创建完毕了，自然checkThread就起作用了，抛出异常顺理成章。

第一种做法中，虽然是在子线程中setText，但是这时候View还没画出来呢，所以并不会调用之后的invalidate，而相当于只是设置TextView的一个属性，不会invalidate，就没有后面的那些方法调用了，归根结底，就不会调用ViewRootImpl的checkThread，也就不会报错。而第二种方法，调用setText之后，就会引发后面的一系列的方法调用，VIew要刷新界面，ViewGroup要更新布局，计算子View的大小位置，到最后，ViewRootImpl就会checkThread，就崩了。

所以，严格上来说，第一种方法虽然在子线程了设置View属性，但是不能够归结到”更新View”的范畴，因为还没画出来呢，就没有所谓的更新。

当我们执行Thread.sleep时候，这时候onStart、onResume都执行了，子线程再调用setText的时候，就会崩溃。

那么说，在onStart()或者onResume()里面执行线程操作UI也是可以的：

@Override
protected void onStart() {
super.onStart();
thread = new Thread(new Runnable() {
@Override
public void run() {
textView.setText("text text text");

}
});
thread.start();
}
登录后复制

@Override
protected void onResume() {
super.onResume();
thread = new Thread(new Runnable() {
@Override
public void run() {
textView.setText("text text text");

}
});
thread.start();
}
登录后复制

注意的是：当你在来回切换界面的时候，onStart()和onResume()是会再执行一遍的，这时候程序就崩溃了！

1、能不能在非UI线程中更新UI呢？
答案：能、当然可以

2、View的运行和Activity的生命周期有什么必然联系吗？
答案：没有、或者隐晦地说没有必然联系

3、除了Handler外是否还有更简便的方式在非UI线程更新UI呢？
答案：有、而且还不少，Activity.runOnUiThread(Runnable)、View.Post(Runnable)、View.PostDelayed(Runnable,long)、AsyncTask、其内部实现原理都是向此View的线程的内部消息队列发送一个Message消息，并传送数据和处理方式，省去了自己再写一个专门的Handler去处理。

4、在子线程里面用Toast也会报错，加上Looper.prepare和Looper.loop就可以了，这里可以这样做吗？
答案当然是不可以。Toast和View本质上是不一样的，Toast在子线程报错，是因为Toast的显示需要添加到一个MessageQueue中，然后Looper取出来，发给Handler调用显示，子线程因为没有Looper，所以需要加上Looper.prepare和Looper.loop创建一个Looper,但是实质上，这还是在子线程调用，所以还是会报错的！

5、为什么Android要求只能在UI主线程中更改View呢
这就要说到Android的单线程模型了，因为如果支持多线程修改View的话，由此产生的线程同步和线程安全问题将是非常繁琐的，所以Android直接就定死了，View的操作必须在UI线程，从而简化了系统设计。

参考文章
为什么我们可以在非UI线程中更新UI
【Android开发经验】来来来，同学，咱们讨论一下“只能在UI主线程更新View”这件小事
线程
android
ui
女式凉鞋，时尚，优雅，透气，货到付款！
精选推荐
广告

可能是全网最简单透彻的安卓子线程更新 UI 解析
71阅读·0评论·0点赞
2019年4月24日
android 不能在子线程中更新ui的讨论和分析
1.5W阅读·7评论·14点赞
2016年1月26日
android.view.ViewRootImpl$: Only the original thread that created
140阅读·0评论·0点赞
2022年9月23日
Looper.prepare()和Looper.loop()，在子线程中更新UI
2520阅读·0评论·0点赞
2016年5月2日
Android为什么能在子线程中更新UI
305阅读·0评论·1点赞
2020年4月9日
android多线程中更新ui,Android 在子线程中更新UI
146阅读·0评论·0点赞
2021年6月3日
Android子线程更新UI就会Crash么
1781阅读·0评论·4点赞
2017年4月1日
为什么只能在主线程中操作UI？为什么子线程中setText不报错？
3970阅读·1评论·5点赞
2017年6月27日
Android 子线程更新TextView的text 不抛出异常原因 分析总结
1211阅读·0评论·3点赞
2019年7月10日
非主线程更新UI
210阅读·0评论·0点赞
2018年4月12日
非 UI 线程中更新 UI
215阅读·0评论·0点赞
2021年4月29日
【Android】 Handler——子线程更新UI
722阅读·1评论·4点赞
2019年12月29日
android-如何在子线程中更新ui
4019阅读·4评论·2点赞
2016年8月23日
SurfaceView
251阅读·0评论·0点赞
2019年3月8日
非UI线程中更新UI
373阅读·0评论·0点赞
2018年7月10日
QT非UI线程更新UI(跨线程更新UI)
275阅读·0评论·0点赞
2022年9月21日
Android开发之UI线程和非UI线程
1619阅读·0评论·1点赞
2020年4月5日
非UI线程可不可以更新UI（一）
1265阅读·0评论·2点赞
2016年2月29日
为什么我们可以在非UI线程中更新UI
2.8W阅读·56评论·35点赞
2015年2月3日
去首页
看看更多热门内容

㈡ 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子线程真的不能更新UI么

可以的
如果在onCreate中通过子线程直接更新UI，并不会抛异常

㈣ 每个Android 都应必须了解的多线程知识点~

进程是系统调度和资源分配的一个独立单位。

在Android中，一个应用程序就是一个独立的集成，应用运行在一个独立的环境中，可以避免其他应用程序/进程的干扰。当我们启动一个应用程序时，系统就会创建一个进程（该进程是从Zygote中fork出来的，有独立的ID），接着为这个进程创建一个主线程，然后就可以运行MainActivity了，应用程序的组件默认都是运行在其进程中。开发者可以通过设置应用的组件的运行进程，在清单文件中给组件设置：android:process = "进程名";可以达到让组件运行在不同进程中的目的。让组件运行在不同的进程中，既有好处，也有坏处。我们依次的说明下。

好处：每一个应用程序（也就是每一个进程）都会有一个内存预算，所有运行在这个进程中的程序使用的总内存不能超过这个值，让组件运行不同的进程中，可以让主进程可以拥有更多的空间资源。当我们的应用程序比较大，需要的内存资源比较多时（也就是用户会抱怨应用经常出现OutOfMemory时），可以考虑使用多进程。

坏处：每个进程都会有自己的虚拟机实例，因此让在进程间共享一些数据变得相对困难，需要采用进程间的通信来实现数据的共享。

线程是进程的一个实体，是CPU调度和分派的基本单位，它是比进程更小的能独立运行的基本单位。

在Android中，线程会有那么几种状态：创建、就绪、运行、阻塞、结束。当应用程序有组件在运行时，UI线程是处于运行状态的。默认情况下，应用的所有组件的操作都是在UI线程里完成的，包括响应用户的操作（触摸，点击等），组件生命周期方法的调用，UI的更新等。因此如果UI线程处理阻塞状态时(在线程里做一些耗时的操作，如网络连接等)，就会不能响应各种操作，如果阻塞时间达到5秒，就会让程序处于ANR（application not response）状态。

1.线程作用

减少程序在并发执行时所付出的时空开销，提高操作系统的并发性能。

2.线程分类

守护线程、非守护线程（用户线程）

2.1 守护线程

定义：守护用户线程的线程，即在程序运行时为其他线程提供一种通用服务
常见：如垃圾回收线程
设置方式：thread.setDaemon(true);//设置该线程为守护线程

2.2 非守护线程（用户线程）

主线程 & 子线程。

2.2.1 主线程（UI线程）

定义：Android系统在程序启动时会自动启动一条主线程
作用：处理四大组件与用户进行交互的事情（如UI、界面交互相关）
因为用户随时会与界面发生交互，因此主线程任何时候都必须保持很高的响应速度，所以主线程不允许进行耗时操作，否则会出现ANR。

2.2.2 子线程（工作线程）

定义：手动创建的线程
作用：耗时的操作（网络请求、I/O操作等）

2.3 守护线程与非守护线程的区别和联系

区别：虚拟机是否已退出，即
a. 当所有用户线程结束时，因为没有守护的必要，所以守护线程也会终止，虚拟机也同样退出
b. 反过来，只要任何用户线程还在运行，守护线程就不会终止，虚拟机就不会退出

3.线程优先级

3.1 表示

线程优先级分为10个级别，分别用Thread类常量表示。

3.2 设置

通过方法setPriority(int grade)进行优先级设置，默认线程优先级是5，即 Thread.NORM_PRIORITY。

4.线程状态

创建状态：当用 new 操作符创建一个线程的时候

就绪状态：调用 start 方法，处于就绪状态的线程并不一定马上就会执行 run 方法，还需要等待CPU的调度

运行状态：CPU 开始调度线程，并开始执行 run 方法

阻塞（挂起）状态：线程的执行过程中由于一些原因进入阻塞状态，比如：调用 sleep/wait 方法、尝试去得到一个锁等

结束（消亡）状态：run 方法执行完 或者 执行过程中遇到了一个异常

（1）start()和run()的区别

通过调用Thread类的start()方法来启动一个线程，这时此线程是处于就绪状态，并没有运行。调用Thread类调用run()方法来完成其运行操作的，方法run()称为线程体，它包含了要执行的这个线程的内容，run()运行结束，此线程终止，然后CPU再调度其它线程。

（2）sleep()、wait()、yield()的区别

sleep()方法属于Thread类，wait()方法属于Object类。
调用sleep()方法，线程不会释放对象锁，只是暂停执行指定的时间，会自动恢复运行状态；调用wait()方法，线程会放弃对象锁，进入等待此对象的等待锁定池，不调用notify()方法，线程永远处于就绪（挂起）状态。

yield()直接由运行状态跳回就绪状态，表示退让线程，让出CPU，让CPU调度器重新调度。礼让可能成功，也可能不成功，也就是说，回到调度器和其他线程进行公平竞争。

1.Android线程的原则

（1）为什么不能再主线程中做耗时操作
防止ANR, 不能在UI主线程中做耗时的操作，因此我们可以把耗时的操作放在另一个工作线程中去做。操作完成后，再通知UI主线程做出相应的响应。这就需要掌握线程间通信的方式了。 在Android中提供了两种线程间的通信方式：一种是AsyncTask机制，另一种是Handler机制。

（2）为什么不能在非UI线程中更新UI 因为Android的UI线程是非线程安全的，应用更新UI，是调用invalidate()方法来实现界面的重绘，而invalidate()方法是非线程安全的，也就是说当我们在非UI线程来更新UI时，可能会有其他的线程或UI线程也在更新UI，这就会导致界面更新的不同步。因此我们不能在非UI主线程中做更新UI的操作。

2.Android实现多线程的几种方式

3.为何需要多线程

多线程的本质就是异步处理，直观一点说就是不要让用户感觉到“很卡”。

4.多线程机制的核心是啥

多线程核心机制是Handler

推荐Handler讲解视频： 面试总被问到Handler？带你从源码的角度解读Handler核心机制

根据上方提到的 多进程、多线程、Handler 问题，我整理了一套 Binder与Handler 机制解析的学习文档，提供给大家进行学习参考，有需要的可以 点击这里直接获取！！！ 里面记录许多Android 相关学习知识点。

㈤ 如何在android一条单独线程，更新ui

方法有两种：
通过继承Thread类，重写Run方法来实现
通过继承接口Runnable实现多线程
主要接受子线程发送的数据, 并用此数据配合主线程更新UI.

Handler的主要作用：主要用于异步消息的处理

Handler的运行过程：
当（子线程）发出一个消息之后，首先进入一个（主线程的）消息队列，发送消息的函数即刻返回，而在主线程中的Handler逐个的在消息队列中将消息取出，然后对消息进行处理。这样就实现了跨线程的UI更新（实际上还是在主线程中完成的）。
这种机制通常用来处理相对耗时比较长的操作，如访问网络比较耗时的操作，读取文大文件，比较耗时的操作处理等。

在大白话一点的介绍它的运行过程：
启动应用时Android开启一个主线程
(也就是UI线程) , 如果此时需要一个耗时的操作，例如:
联网读取数据，或者读取本地较大的一个文件的时候，你不能把这些操作放在主线程中，如果你放在主线程中的话，界面会出现假死现象（这也就是你在主线程中直接访问网络时会提示你异常的原因，如我们上篇文章所述Android主线程不能访问网络异常解决办法）。

㈥ android 线程中怎么更新ui进度条

如果你用的是标准的ProgressBar类，那么调用setProgress(int progress)方法进行更新即可。
不过如果加载处理不是在UI线程，那就需要用Handler去更新了
举例如下：
int progress = calculateProgress();
ProgressBar progressBar = mActivity.getProgressBar();
// 获取主线程Handler。需要编写getHandler()方法
Handler handler = mActivity.getHandler();
handler.post(new Runnable() {
void run() {
progressBar.setProgress(progress);
}
})

㈦ 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 在子线程中更新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开发中要经常用到这种机制。

㈨ 为什么我们可以在非UI线程中更新UI

• 先看setProgress(int progress)方法的实现

  如果有描述不清楚的话，大家可以看看ProgressBar.java源码的实现。

㈩ android编程为什么不可以在子线程更新ui

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