本文共 5672 字，大约阅读时间需要 18 分钟。

 Question:

一、onLooperPrepared()可以在Looper开始循环之前做一些什么样的Setup操作呢？？

二、synchronized(this)，放在run()函数中保护Looper的获取过程，为啥要保护呢？

       getLooper()中也加了synchronized(this)，为哈？

        ------->run()方法中ynchronized(this)相当于一个setter，而getLooper()是一个getter，如果外部线程调用getLooper()方法，则需要考虑同步。

三、在getLooper()中 需要判断mLooper是否为空，是不是说在HandlerThread执行run()方法之前，会有可能被调用getLooper()???

/* * Copyright (C) 2006 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * *      http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */package android.os;import android.annotation.NonNull;import android.annotation.Nullable;/** * Handy class for starting a new thread that has a looper. The looper can then be  * used to create handler classes. Note that start() must still be called. */public class HandlerThread extends Thread {    int mPriority;    int mTid = -1;    Looper mLooper;    private @Nullable Handler mHandler;    public HandlerThread(String name) {        super(name);        mPriority = Process.THREAD_PRIORITY_DEFAULT;    }        /**     * Constructs a HandlerThread.     * @param name     * @param priority The priority to run the thread at. The value supplied must be from      * {@link android.os.Process} and not from java.lang.Thread.     */    public HandlerThread(String name, int priority) {        super(name);        mPriority = priority;    }        /**     * Call back method that can be explicitly overridden if needed to execute some     * setup before Looper loops.     * 在Looper开始循环之前可以执行一些setup操作。啥操作呢？？？     */    protected void onLooperPrepared() {    }    @Override    public void run() {        mTid = Process.myTid();        Looper.prepare();        synchronized (this) {            /*                为什么要加this锁呢？                两个并发线程访问同一个对象Object中的synchronized (this)代码块时，一个线程需要等待                这个线程的获取mLooper()的操作也会被其他线程使用嘛？？？？            */            mLooper = Looper.myLooper();            notifyAll();        }        Process.setThreadPriority(mPriority);        onLooperPrepared();        Looper.loop();        mTid = -1;    }        /**     * This method returns the Looper associated with this thread. If this thread not been started     * or for any reason isAlive() returns false, this method will return null. If this thread     * has been started, this method will block until the looper has been initialized.       * @return The looper.     */    public Looper getLooper() {        if (!isAlive()) {            return null;        }                // If the thread has been started, wait until the looper has been created.        synchronized (this) {            //这儿也加锁了。。。。            while (isAlive() && mLooper == null) {                //mLooper为啥会出现null？？？？                try {                    wait();                } catch (InterruptedException e) {                }            }        }        return mLooper;    }    /**     * @return a shared {@link Handler} associated with this thread     * @hide     */    @NonNull    public Handler getThreadHandler() {        if (mHandler == null) {            mHandler = new Handler(getLooper());        }        return mHandler;    }    /**     * Quits the handler thread's looper.     * 
     * Causes the handler thread's looper to terminate without processing any     * more messages in the message queue.     * 
     * Any attempt to post messages to the queue after the looper is asked to quit will fail.     * For example, the {@link Handler#sendMessage(Message)} method will return false.     * 
     * Using this method may be unsafe because some messages may not be delivered     * before the looper terminates.  Consider using {@link #quitSafely} instead to ensure     * that all pending work is completed in an orderly manner.     * 
     *     * @return True if the looper looper has been asked to quit or false if the     * thread had not yet started running.     *     * @see #quitSafely     */    public boolean quit() {        Looper looper = getLooper();        if (looper != null) {            looper.quit();            return true;        }        return false;    }    /**     * Quits the handler thread's looper safely.     * 
     * Causes the handler thread's looper to terminate as soon as all remaining messages     * in the message queue that are already due to be delivered have been handled.     * Pending delayed messages with due times in the future will not be delivered.     * 
     * Any attempt to post messages to the queue after the looper is asked to quit will fail.     * For example, the {@link Handler#sendMessage(Message)} method will return false.     * 
     * If the thread has not been started or has finished (that is if     * {@link #getLooper} returns null), then false is returned.     * Otherwise the looper is asked to quit and true is returned.     * 
     *     * @return True if the looper looper has been asked to quit or false if the     * thread had not yet started running.     */    public boolean quitSafely() {        Looper looper = getLooper();        if (looper != null) {            looper.quitSafely();            return true;        }        return false;    }    /**     * Returns the identifier of this thread. See Process.myTid().     */    public int getThreadId() {        return mTid;    }}

转载地址：https://blog.csdn.net/mengmengmengwang/article/details/108223207 如侵犯您的版权，请留言回复原文章的地址，我们会给您删除此文章，给您带来不便请您谅解！