android通过Handler使子线程更新UI

Posted

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了android通过Handler使子线程更新UI相关的知识,希望对你有一定的参考价值。

参考技术A

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 copy

Handler mHandler = new Handler()         

@Override    

public void handleMessage(Message msg)     

super.handleMessage(msg);    

switch (msg.what)     

case 0:    

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

String data = (String)msg.obj;                    

updateWeather();    

textView.setText(data);    

break;    

default:    

break;    

    

    

;    

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

java代码:

private void updateWeather()                             

new Thread(new Runnable()    

@Override    

public void run()     

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

mHandler.sendEmptyMessage(0);    

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

Message msg =new Message();    

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

mHandler.sendMessage(msg);    

    

).start();    

   

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

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

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

java代码:

new Thread()     

public void run()     

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

runOnUiThread(new Runnable()    

@Override    

public void run()     

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

imageView.setImageBitmap(bitmap);    

    

);    

    

.start();    

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

java代码:

Activity activity = (Activity) imageView.getContext();    

activity.runOnUiThread(new Runnable()       

@Override    

public void run()     

imageView.setImageBitmap(bitmap);    

    

);    

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


3.
View.post(Runnable r) 

java代码:

imageView.post(new Runnable()    

@Override    

public void run()     

imageView.setImageBitmap(bitmap);    

    

);    

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

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

Android---Handler消息处理机制

       搞Android的人都知道。android是不同意你在子线程中更新UI操作的。这主要出于线程安全方面的考虑。通常的做法是在主线程中创建一个Handler对象,在子线程中创建一个Message对象。该Message对象中封装一些更新UI操作的数据,通过Handler的sendMessage方法发送出去,主线程利用Handler的handleMessage方法来对该Message进行对应的处理。但发现没有,子线程调用Handler的sendMessage发出Message之后,消息是怎么传递到主线程的handleMessage方法里面进而进行处理的呢。接下来我们从源代码角度慢慢进行分析:

       先来看看寻常我们是怎么使用handler的:

实例1:

public class MainActivity extends Activity {

	public Handler mHandler;
	@Override
	protected void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		setContentView(R.layout.activity_main);
		mHandler = new Handler(){

			@Override
			public void handleMessage(Message msg) {
				switch (msg.what) {
				case 1:
					System.out.println("接收到空消息");
					break;
				default:
					break;
				}
			}
		};
		new Thread(new Runnable() {
			
			@Override
			public void run() {
				mHandler.sendEmptyMessage(1);
			}
		}).start();
	}
}

解释:

能够看到。在子线程中我们使用的是主线程的Handler来进行sendMessage的,那么问题来了。子线程中能够存在自己的Handler么?而且用这个Handler来sendMessage?以下我们进行測试:

实例2:

public class MainActivity extends Activity {

	public Handler mHandler;
	@Override
	protected void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		setContentView(R.layout.activity_main);
		mHandler = new Handler(){

			@Override
			public void handleMessage(Message msg) {
				switch (msg.what) {
				case 1:
					System.out.println("接收到空消息");
					break;
				default:
					break;
				}
			}
		};
		new Thread(new Runnable() {
			@Override
			public void run() {
				Handler handler = new Handler();
				handler.sendEmptyMessage(1);
			}
		}).start();
	}
}

解释:

这段程序我们调用的是自己的子线程自己的Handler,执行之后报了下面错误:

E/AndroidRuntime(963): java.lang.RuntimeException: Can‘t create handler inside thread that has not called Looper.prepare()

意思就是说在没有调用Looper.prepare()之前是不同意创建Handler对象的,这一点我们能够从Handler的构造函数中查看原因:

下面是Handler的构造函数源代码:

public Handler() {
    this(null, false);
}
public Handler(Callback callback, boolean async) {
    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());
        }
    }
    //从ThreadLocal获取到Looper对象,这个对象是由Looper.prepare()函数创建而且加入到ThreadLocal中的
    mLooper = Looper.myLooper();
    if (mLooper == null) {
        <span style="color:#ff6666;">throw new RuntimeException(
            "Can't create handler inside thread that has not called Looper.prepare()");</span>
    }
    //获得Looper对象中的MessageQueue
    mQueue = mLooper.mQueue;
    mCallback = callback;
    mAsynchronous = async;
}

解释:

抛出异常原因在于mLooper为null,而mLooper是一个Looper对象,这个对象是通过Looper的static方法myLooper从ThreadLocal中获取的。而创建Looper对象是由Looper的static方法prepare()实现的,而且将其增加到了ThreadLocal中。

因此我们找到了抛出异常的原因。也就是Looper对象为null。正如异常中所提示的一样,须要调用Looper.prepare()来创建Looper对象。

我们来查看Looper的static方法prepare源代码:

public static void prepare() {
    prepare(true);//创建子线程的Looper对象的时候,此处始终为true。可是待会会发现主线程的Looper对象在创建的时候此參数值是false
}
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对象之前先查看ThreadLocal中是否已经存在一个Looper对象。一个线程仅仅能创建一个Looper对象,假设多次创建Looper会抛异常。假设不存在的话,调用new Looper(true)创建当前线程的Looper对象,而且将其set到ThreadLocal中(在此多少能够发现ThreadLocal事实上是一个Map型的数据结构实现的,其源代码分析以后补上),来吧,该看看new Looper(true)究竟做了写什么事的时候了,源代码例如以下:

private Looper(boolean quitAllowed) {
        mQueue = new MessageQueue(quitAllowed);//创建了一个MessageQueue消息队列
        mRun = true;
        mThread = Thread.currentThread();
    }

解释:

非常easy,就是创建了一个MessageQueue而且将mThread设置为当前线程;

好了,至此我们创建了Looper对象。那么我们把Looper.prepare()增加到实例2的Handler handler = new Handler( )之前,看看会有什么事发生吧:

实例3:

public class MainActivity extends Activity {

	public Handler mHandler;
	@Override
	protected void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		setContentView(R.layout.activity_main);
		mHandler = new Handler(){

			@Override
			public void handleMessage(Message msg) {
				switch (msg.what) {
				case 0:
					System.out.println("1:   "+Thread.currentThread());
					break;
				default:
					break;
				}
			}
		};
		new Thread(new Runnable() {
			@Override
			public void run() {
				Looper.prepare();
				Handler handler = new Handler(){
					@Override
					public void handleMessage(Message msg) {
						System.out.println("2:  "+Thread.currentThread());
					}
				};
				handler.sendEmptyMessage(0);
				mHandler.sendEmptyMessage(0);
			}
		}).start();
	}
}

解释:

输出结果:1:   Thread[main,5,main]

发如今我们的输出信息中,并没有输出:子线程中handleMessage的信息

原因事实上也非常easy:你如今仅仅是有Looper对象了,可是你并没有对Looper对象进行不论什么操作,就像你非常有钱,可是你不花这些钱,那钱还有什么用呢?那该怎么用呢?要想找到这个问题的答案,我们须要分析主线程中是怎么创建Looper对象以及怎么使用这个Looper对象的呢?

我们知道应用程序是通过ActivityThread主线程来创建的,为什么这样子说呢?看看源代码就知道啦:

public static void main(String[] args) {
        SamplingProfilerIntegration.start();

        // CloseGuard defaults to true and can be quite spammy.  We
        // disable it here, but selectively enable it later (via
        // StrictMode) on debug builds, but using DropBox, not logs.
        CloseGuard.setEnabled(false);

        Environment.initForCurrentUser();

        // Set the reporter for event logging in libcore
        EventLogger.setReporter(new EventLoggingReporter());

        Security.addProvider(new AndroidKeyStoreProvider());

        Process.setArgV0("<pre-initialized>");

        Looper.prepareMainLooper();//创建Looper对象

        ActivityThread thread = new ActivityThread();
        thread.attach(false);

        if (sMainThreadHandler == null) {
            sMainThreadHandler = thread.getHandler();
        }

        AsyncTask.init();

        if (false) {
            Looper.myLooper().setMessageLogging(new
                    LogPrinter(Log.DEBUG, "ActivityThread"));
        }

        Looper.loop();//使用Looper对象中的MessageQueue来进行消息处理

        throw new RuntimeException("Main thread loop unexpectedly exited");
    }

解释:

由于这个类里面有我们苦苦想要寻找的main函数,可能你曾经也会疑惑android程序究竟是怎么启动的呢?如今明确了吧,入口函数main在这里呢,来看看里面我们可能熟悉的代码吧。Looper.prepareMainLooper()有点类似于我们之前见过的Looper.prepare()吧,显然他也是用来创建一个Looper对象而且放入ThreadLocal里面的。仅仅只是他是在主线程中创建的:

public static void prepareMainLooper() {
        <span style="color:#ff6666;">prepare(false);//这里的參数值是false,子线程创建Looper的prepare參数值是true</span>
        synchronized (Looper.class) {
            if (sMainLooper != null) {
                throw new IllegalStateException("The main Looper has already been prepared.");
            }
            sMainLooper = myLooper();
        }
    }

解释:

在有了Looper对象之后。main方法中的Looper.loop()就是利用Looper对象中的MessageQueue来进行消息接收和处理的。源代码例如以下:

public static void loop() {
        final Looper me = myLooper();//获得Looper对象
        if (me == null) {
            throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
        }
        <span style="color:#ff6666;">final MessageQueue queue = me.mQueue;//获得Looper对象中的MessageQueue</span>

        // 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();
        //採用死循环的方式从MessageQueue中取出消息
        for (;;) {
           <span style="color:#ff6666;"> Message msg = queue.next(); // might block</span>
            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);
            }
           //调用dispatchMessage来进行消息的处理
            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();
        }
    }

解释:

详细过程是:

(1)首先通过myLooper( )静态方法获取到Looper对象;

(2)通过获取到的Looper对象来获取到该对象中的MessageQueue消息处理队列;

(3)採用死循环的方式对消息队列中的每一个消息调用此消息所在的handler(通过msg.target获取此handler)的dispatchMessage方法进行处理;

(4)消息处处理结束后调用recycle方法回收消息;
这里最重要的方法当然就是dispatchMessage消息处理和消息回收函数啦,接下来我们先分析一下消息是怎么传递到MessageQueue队列中的。随后再来分别来看看究竟在dispatchMessage和recycle这两个函数中做了什么?

要想处理消息,首先你得有消息吧。就像你想花钱一样,首先你总得有钱吧,handler机制中,消息是从哪来的呢?

非常显然从实例中我们能够看出,我们都是通过handler的sendEmptyMessage方法来发送消息的,在handler中存在非常多发送消息的方法,可是归根结底他们最后都会调用sendMessageAtTime方法的(无论你是採用Runnable的post机制还是採用Message的send机制),源代码例如以下:

public boolean sendMessageAtTime(Message msg, long uptimeMillis) {
        MessageQueue queue = mQueue;
        if (queue == null) {
            RuntimeException e = new RuntimeException(
                    this + " sendMessageAtTime() called with no mQueue");
            Log.w("Looper", e.getMessage(), e);
            return false;
        }
        return enqueueMessage(queue, msg, uptimeMillis);
    }
解释:

这种方法有两个參数。一个是想要传递给主线程的Message对象,uptimeMillis表示我们发送消息的时间,假设调用的不是sendMessageDelayed的话。uptimeMillis的值为0。在消息队列非空的前提下调用enqueueMessage将消息增加到队列中;

我们来看看enqueueMessage的源代码:

private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
        msg.target = this;
        if (mAsynchronous) {
            msg.setAsynchronous(true);
        }
        return queue.enqueueMessage(msg, uptimeMillis);
    }
解释:

非常easy。他就是直接调用了MessageQueue队列中的enqueueMessage入队方法,来看MessageQueue里面的enqueueMessage方法源代码:

    boolean enqueueMessage(Message msg, long when) {
        if (msg.isInUse()) {
            throw new AndroidRuntimeException(msg + " This message is already in use.");
        }
        if (msg.target == null) {
            throw new AndroidRuntimeException("Message must have a target.");
        }

        synchronized (this) {
            if (mQuitting) {
                RuntimeException e = new RuntimeException(
                        msg.target + " sending message to a Handler on a dead thread");
                Log.w("MessageQueue", e.getMessage(), e);
                return false;
            }

            msg.when = when;
            Message p = mMessages;
            boolean needWake;
            if (p == null || when == 0 || when < p.when) {
                // New head, wake up the event queue if blocked.
                msg.next = p;
                mMessages = msg;
                needWake = mBlocked;
            } else {
                // Inserted within the middle of the queue.  Usually we don't have to wake
                // up the event queue unless there is a barrier at the head of the queue
                // and the message is the earliest asynchronous message in the queue.
                needWake = mBlocked && p.target == null && msg.isAsynchronous();
                Message prev;
                for (;;) {
                    prev = p;
                    p = p.next;
                    if (p == null || when < p.when) {
                        break;
                    }
                    if (needWake && p.isAsynchronous()) {
                        needWake = false;
                    }
                }
                msg.next = p; // invariant: p == prev.next
                prev.next = msg;
            }

            // We can assume mPtr != 0 because mQuitting is false.
            if (needWake) {
                nativeWake(mPtr);
            }
        }
        return true;
    }
解释:

这里我们仅仅讨论核心代码。由于要插入Message对象到队列。所以我们必须找到队尾元素的位置。而这个位置在上面的源代码是通过p的指针值是否为空来进行推断的,假设p本身为空的话,说明p已经到达了队尾,我们仅仅须要将该Message对象插入到p之后就可以啦,假如队列本身为空的话,那么p本身就是队尾。直接插入;假如队列本身不为空的话。须要遍历整个队列。找到队尾元素就可以啦,然后插入,我们能够看到。MessageQueue的队列是由单链表来实现的。
好了,这下子Message对象增加到了MessageQueue中啦,随后就是我们该怎么处理的问题啦;

查看Handler.java源代码中的dispatchMessage方法:

 public void dispatchMessage(Message msg) {
        if (msg.callback != null) {
            handleCallback(msg);
        } else {
            if (mCallback != null) {
                if (mCallback.handleMessage(msg)) {
                    return;
                }
            }
            handleMessage(msg);
        }
    }

解释:

在正式分析此方法之前先补充一点。Handler支持两种消息类型。Runnable和Message,因此发送消息提供了post(Runnable r)和sendMessage(Message msg)两个方法。Message中的callback属性存储的就是Runnable对象;

详细分析:

(1)首先查看该Message的callback字段是否为null,即查看此消息是否存在Runnable属性值(该值是通过post方法将其增加到Message的callback中的)。有的话则运行handleCallback方法。该方法会运行Runnable的run方法,源代码例如以下:

private static void handleCallback(Message message) {
        message.callback.run();
    }
(2)假设Message的callback字段为null的话,则查看是否存在外部的Callback类型对象,这个值是在创建Handler的时候通过构造函数传递进来的,假设存在的话运行该Callback对象的handleMessage方法;

(3)假设既不存在Runnable对象。又不存在外部的Callback对象的话,则直接运行handler自身的handleMessage方法,这种方法须要我们在new Handler之后进行重写,由于Handler本身是没有实现这种方法的。

 public void handleMessage(Message msg) {
 }
好了,消息已经处理结束啦,接下来我们就该回收该消息啦。也就是Looper.loop( )方法所运行的最后一句代码,msg.recycle( ),再次回到了源代码级别查看:

   public void recycle() {
        clearForRecycle();//将Message的各种标识位所有归位

        synchronized (sPoolSync) {
            if (sPoolSize < MAX_POOL_SIZE) {
                next = sPool;
                sPool = this;
                sPoolSize++;//将该消息返回给消息缓冲池
            }
        }
    }
void clearForRecycle() {
        flags = 0;
        what = 0;
        arg1 = 0;
        arg2 = 0;
        obj = null;
        replyTo = null;
        when = 0;
        target = null;
        callback = null;
        data = null;
    }
解释:

释放消息前首先将消息里面的各个消息标识位归位。随后将该消息增加到消息缓冲池中,以备下次我们使用消息的时候能够直接调用Message.obtain( )方法来获取消息。这样子就不用new Message( )啦,从而降低了new对象的时空开销,这就是缓冲机制的优点,由于缓冲池里面的全部消息对象是能够反复使用的。仅仅是在使用的时候进行必要标识位的设置就可以,看看Message的obtain方法就一目了然啦:

public static Message obtain() {
        synchronized (sPoolSync) {
            if (sPool != null) {
                Message m = sPool;
                sPool = m.next;
                m.next = null;
                sPoolSize--;
                return m;
            }
        }
        return new Message();
    }
解释:

我们能够发现,仅仅有当消息缓冲池为null的时候我们才会new Message出来,假设消息缓冲池不为空的话,直接获取缓冲池中的第一个,而且让缓冲池中的消息个数降低1就可以;

至此,整个消息处理过程已经结束了。
那么我们应该知道怎么改动实例3让他可以输出:子线程中handleMessage的信息
实例4:

public class MainActivity extends Activity {

	public Handler mHandler;
	@Override
	protected void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		setContentView(R.layout.activity_main);
		mHandler = new Handler(){

			@Override
			public void handleMessage(Message msg) {
				switch (msg.what) {
				case 0:
					System.out.println("1:   "+Thread.currentThread());
					break;
				default:
					break;
				}
			}
		};
		new Thread(new Runnable() {
			@Override
			public void run() {
				Looper.prepare();
				Handler handler = new Handler(){
					@Override
					public void handleMessage(Message msg) {
						System.out.println("2:  "+Thread.currentThread());
					}
				};
				handler.sendEmptyMessage(0);
				mHandler.sendEmptyMessage(0);
				Looper.loop();
			}
		}).start();
	}
}
区别就是添加了Looper.loop( )这句代码而已。

输出结果:

2:  Thread[Thread-120,5,main]
1:   Thread[main,5,main]

究竟,我们能够做做总结啦。看看Handler消息处理机制中究竟用到些什么?

1.  Looper
 (1)创建消息循环

     prepare( )用于创建Looper对象,而且保存到ThreadLocal中;

 (2)获得消息循环对象

     myLooper( ),採用ThreadLocal的get方式获取存储在ThreadLocal里面的消息循环对象;

 (3)開始消息循环

     详细过程:

    首选获取MessageQueue里面的队头Message

    接着调用该Message所在handler的dispatchMessage方法。最后在dispatchMessage里面调用handlerMessage方法

    消息使用完成之后将其增加到本地消息缓冲池中。以便下次使用,节省创建Message的开销
2. MessageQueue

    每一个Looper对象相应一个MessageQueue队列,他是消息的存储区,向Handler发送的消息终于都会存储到该队列中
 (1)消息入队

     消息入队採用的方法是enqueueMessage( )。首先会查看队列是否为空,假设为空。则直接入队就可以。假设非空须要轮询链表,依据when从低到高的顺序插入链表的合适位置。这里的队列是由单链表实现的;

 (2)轮询队列

     next( )用于获取MessageQueue中的Message

3. Handler

 (1)获取消息

     以obtain打头的方法,这些方法实现的功能就是从本地消息缓冲池中获取消息,这样做的目的就仅仅是为了提高时空效率,这些方法实际上还是调用的Message中的各种obtain方法

 (2)发送消息

     Handler支持两种消息类型,各自是Runnable和Message,他们发送消息的方法各自是以post打头的post(Runnable runnable)和以sendMessage(Message message),可是post方法中的Runnable对象在最后还是会被封装到Message中称为Message的属性callback的值,也就是说原则上还是自由Message这样的方式的,在调用各种sendMessage的时候。都会终于运行sendMessageAtTime。而在这种方法里面就会调用MessageQueue的enqueueMessage来将Message增加到队列中啦;

 (3)处理消息

     Handler中处理消息的開始方法是dispatchMessage,在这种方法里面会调用Handler本身的handleMessage方法。而这种方法是须要我们在创建Handler的时候重写的

4. Message

 (1)创建消息

      创建消息有两种方式。我们能够通过new Message( )的方式创建一个新的Message,也能够通过Message.obtain从本地消息缓冲池中获取一个消息,后者在时空上效率更高;

 (2)释放消息

     消息使用完成之后。调用recycle函数释放消息,将该消息增加到本地消息缓冲池中,以便下次使用;

     以上就是Handler消息处理机制的主要内容了。我们也自己实现了一个子线程中的handler而且创建了子线程自己的MessageQueue,此外子线程可以通过loop方法处理传递给子线程的消息了。可是假设每次我们想让子线程实现这种功能的话,我们都必须利用Looper.prepare( )和Looper.loop( )方法将我们的子线程中的handler代码包裹起来。这样是不是太麻烦啦,这就导致了HandlerThread的出现,在下一篇。我们解说下HandlerThread的源代码分析



























以上是关于android通过Handler使子线程更新UI的主要内容,如果未能解决你的问题,请参考以下文章

如何在android一条单独线程,更新ui ?

关于Handler的理解,子线程不能更新UI的纠正和回调的思考

Android的消息机制

Android面试 Handler机制

Android---Handler消息处理机制

关于Handler