安卓：一个线程可以有几个Looper？如何保证？

首先说明，部分代码和逻辑问的AI，使用的是国内基于ChatGPT3.5的一款AI软件，速度有点慢但是免费，地址是：点击这里

起初我也不知道这个问题答案，对Looper也不是很了解，只知道是从Handler中取消息的中间助手。看了几篇博客发现全都是复制粘贴的，复制粘贴也就算了到底也没讲清楚，于是我就直接去看源码，发表一下我的见解。
首先，Looper的构造方法是一个私有方法：

private Looper(boolean quitAllowed) {
        mQueue = new MessageQueue(quitAllowed);
        mThread = Thread.currentThread();
    }

也就是说无法从类外new一个Looper对象，其次，该类中有一个静态变量：

static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>();

这是一个关键点，这个变量属于类，不属于对象，也就是说只能有一个，且用final修饰初始化之后就不能再改了。
再介绍一下ThreadLocal，它是线程本地存储机制，可以将数据缓存在线程的内部，该线程可以在任意时刻任意方法中获取缓存数据，ThreadLocal类中又有一个ThreadLocalMap：

static class ThreadLocalMap {
        static class Entry extends WeakReference<ThreadLocal<?>> {
            /** The value associated with this ThreadLocal. */
            Object value;

            Entry(ThreadLocal<?> k, Object v) {
                super(k);
                value = v;
            }
        }
        .......

跟HashMap类似，通过键值对保存数据，但是这个键规定得死死的只能是ThreadLocal对象，值就是要保存的值，每一个线程都有一个ThreadLocalMap。

回到Looper，既然不能new一个对象那总得要有个初始化方法吧，于是就有perpare方法：

public static void prepare() {
        prepare(true);
}
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.prepare();

不管调用哪个，反正都是会调用第二个，下面当做是第一个调用该方法，首先通过if语句调用ThreadLocal的get方法判断是否返回个空，来看源码：

public T get() {
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null) {
            ThreadLocalMap.Entry e = map.getEntry(this);
            if (e != null) {
                @SuppressWarnings("unchecked")
                T result = (T)e.value;
                return result;
            }
        }
        return setInitialValue();
    }

首先获取当前线程，将当前线程传入getMap中，获取map对象，来看getMap方法：

ThreadLocalMap getMap(Thread t) {
        return t.threadLocals;
 }

t.threadLocals是什么？
看Thread类源码：

ThreadLocal.ThreadLocalMap threadLocals = null;

上面说过，当做是该线程第一次调用，所以还没赋值，返回为null，返回到get方法

public T get() {
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null) {
            ThreadLocalMap.Entry e = map.getEntry(this);
            if (e != null) {
                @SuppressWarnings("unchecked")
                T result = (T)e.value;
                return result;
            }
        }
        return setInitialValue();
    }

map为空，执行return setInitialValue()，再看setInitialValue()源码：

private T setInitialValue() {
        T value = initialValue();
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null)
            map.set(this, value);
        else
            createMap(t, value);
        return value;
    }

几乎干着和上一个方法同样的事，只是提供了创建键值对 createMap(t, value)方法；
t是当前线程，value是initialValue()获取的，来看这个方法源码：

 protected T initialValue() {
        return null;
    }

直接返回空，所以value为null，一起传到createMap方法里：

  void createMap(Thread t, T firstValue) {
        t.threadLocals = new ThreadLocalMap(this, firstValue);
    }

上面说 t.threadLocals还没有初始化为null，那么在这个函数里对它进行初始化，

一个线程只有一个Thread对象，一个Thread只有一个threadLocals变量，所以说在这里给它初始化完毕之后，当在这个线程再去判断是否为null时，它已经不为null也就不会再初始化了。
顺便看一下ThreadLocalMap的构造方法：

  ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
            table = new Entry[INITIAL_CAPACITY];
            int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
            table[i] = new Entry(firstKey, firstValue);
            size = 1;
            setThreshold(INITIAL_CAPACITY);
        }

table是一个数组，数组怎么保存键值对？一个保存键一个保存值如此循环，通过与运算得出数组下标i，然后将key和value封装保存到数组中，这里不再深究。
我们回到setInitialValue()源码

private T setInitialValue() {
        T value = initialValue();
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null)
            map.set(this, value);
        else
            createMap(t, value);
        return value;
    }

createMap方法完成之后呢，最后发现返回了value，前面提过也就是通过initialValue()返回为null，返回到Looper类的prepare方法里：

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));
    }

返回了null那就运行最后一行代码：

sThreadLocal.set(new Looper(quitAllowed));

new一个Looper对象，传入ThreadLocal的set方法，来看源码：

public void set(T value) {
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null)
            map.set(this, value);
        else
            createMap(t, value);
    }

还是差不多的过程，因为线程没变，上一次已经初始化了map，所以这次map不为null，因此调用set方法：

 private void set(ThreadLocal<?> key, Object value) {
            Entry[] tab = table;
            int len = tab.length;
            int i = key.threadLocalHashCode & (len-1);
            for (Entry e = tab[i];
                 e != null;
                 e = tab[i = nextIndex(i, len)]) {
                ThreadLocal<?> k = e.get();
                if (k == key) {
                    e.value = value;
                    return;
                }
                if (k == null) {
                    replaceStaleEntry(key, value, i);
                    return;
                }
            }
            tab[i] = new Entry(key, value);
            int sz = ++size;
            if (!cleanSomeSlots(i, sz) && sz >= threshold)
                rehash();
        }

跟ThreadLocaMap的构造方法差不多吧，我也没咋看明白，大概意思就是通过与计算出下标，判断要插入的键值对存不存在，存在就取代，不存在就插入，前面说过键是ThreLocal对象，Looper的ThreLocal是静态和final修饰的变量，所以键是不变的，所以插入一次之后就不会插入第二个了。

ok，第一次调用prepare完之后如果再调用呢？

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));
    }

首先还是调用get方法：

public T get() {
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null) {
            ThreadLocalMap.Entry e = map.getEntry(this);
            if (e != null) {
                @SuppressWarnings("unchecked")
                T result = (T)e.value;
                return result;
            }
        }
        return setInitialValue();
    }

map已经初始化了不为null，接下来传入this也就是key也就是调用这个方法的对象也就是sThreadlocal，来获取键值对：

 private Entry getEntry(ThreadLocal<?> key) {
            int i = key.threadLocalHashCode & (table.length - 1);
            Entry e = table[i];
            if (e != null && e.get() == key)
                return e;
            else
                return getEntryAfterMiss(key, i, e);
        }

同样的方法计算得出数组下标，再判断是不是为null且key相等，前面说过key不变且已经初始化了所以符合条件，返回这个节点e，回到get方法：

public T get() {
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null) {
            ThreadLocalMap.Entry e = map.getEntry(this);
            if (e != null) {
                @SuppressWarnings("unchecked")
                T result = (T)e.value;
                return result;
            }
        }
        return setInitialValue();
    }

返回的是非null，就获取这个节点的值也就是value也就是new的Looper对象，回到prepare：

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));
    }

返回了非null，抛出异常，结束运行。

所以一个线程只能有一个Looper，如果保证？简单概括：Looper对象通过ThreadLocalMap保存，一个线程只有一个ThreadLocalMap，ThreadLocalMap保存键值对，该键值对的键为ThreadLocal对象，Looper里的ThreadLocal对象又通过static和final修饰，只能初始化一次。所以只要线程不变，ThreadLocal对象也不变，键也不变，Map中无法插入第二个键值对，因此保证了一个线程只有一个。