Java中的线程回顾

在操作系统的概念里，进程是具有一定独立功能的程序、它是系统进行资源分配和调度的一个独立单位。
在Java的虚拟机中，进程拥有自己独立的虚拟地址空间（准确的说是方法区和堆内存）。
而线程则是CPU调度的基本单元,它没有自己独立的虚拟地址空间，它依附于进程的虚拟地址空间。在Java虚拟机中，线程拥有的不过是PC计数器和方法栈而已。
在Android系统中，进程之间的通信称为IPC，它主要由Binder完成，线程之间由于共享地址空间，各线程都可以对对象进行操作，因此线程间的通信机制更为简单，由轻便的Handler和Looper完成。

线程独有数据

由于同一个进程的线程共享资源，因此，如何保证数据在某线程的私有性变为极为重要，忽略这点会造成著名的多线程同步问题。在Java中，线程被封装为Thread类，一种很常见的思维是维护一个共有的哈希表，然后将线程的私有变量存储起来，当线程需要取用数据时，从哈希表中读取私有数据。

val threadData = ConcurrentHashMap<Thread,Any>()

但是如果这样的话，程序员就需要自己在程序中维护这么一个表，且不说自己能不能记住到底存储了什么，光是表的维护就已经很麻烦了，而且表的更新特别耗费资源。因此，比较好的方法是将数据存储封装在Thread这个类的内部，由于每一个线程都是一个Thread对象，它们需要这个值的时候直接读取其内部的值即可。Android采用了ThreadLocal这个类，实现了在指定线程中存储数据的功能。
首先我们来看一下ThreadLocal类怎么使用:

fun test()
{
    val localAge = ThreadLocal<Int>() // 申请一个Int类型的线程私有变量
    localAge.set(10) //主线程中修改值
    Log.d(Thread.currentThread().toString(),localAge.get().toString()+"-> $localAge")
    Thread({
        localAge.set(12345) //其他线程中修改值
        Log.d(Thread.currentThread().toString(),localAge.get().toString()+"-> $localAge")
    }, "Thread#2").start()
    Thread({
        localAge.set(18) //其他线程中修改值
        Log.d(Thread.currentThread().toString(),localAge.get().toString()+"-> $localAge")
    },"Thread#3").start()

    localAge.set(-33) //主线程中第二次修改值
    Log.d(Thread.currentThread().toString(),localAge.get().toString()+"-> $localAge")
}

输出结果:

01-09 21:33:50.274 11935-11935/cn.suiseiseki.www.androidstudy D/Thread[main,5,main]: 10-> java.lang.ThreadLocal@4368aaa8
01-09 21:33:50.274 11935-11950/cn.suiseiseki.www.androidstudy D/Thread[Thread#2,5,main]: 12345-> java.lang.ThreadLocal@4368aaa8
01-09 21:33:50.279 11935-11935/cn.suiseiseki.www.androidstudy D/Thread[main,5,main]: -33-> java.lang.ThreadLocal@4368aaa8
01-09 21:33:50.279 11935-11951/cn.suiseiseki.www.androidstudy D/Thread[Thread#3,5,main]: 18-> java.lang.ThreadLocal@4368aaa8
可以看到，在不同线程中访问同一个Thread对象，其获取的值不一样，这就是ThreadLocal的奇妙之处
下面我们分析一下ThreadLocal的主要方法:

public void set(T value) {
    Thread t = Thread.currentThread();
    ThreadLocalMap map = getMap(t);
    if (map != null)
        map.set(this, value);
    else
        createMap(t, value);
}
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();
}

其实代码已经很明显了，就是通过不同的Thread对象获取其Thread内部维护的ThreadLocalMap,然后查询是否有这个参数，如果有就返回这个参数的值，如果没有则返回null.对于set方法来说，首先查找线程是否创建了ThreadLocalMap，如果没有则创建之，然后就是正常的map操作了
如果你感兴趣的话，可以再深入了解一下ThreadLocalMap这个类，它内部采用弱引用维护了一个哈希表，这里不再详细介绍。
总之，现在我们已经知道，多个线程之间确实可以互不干扰地存储和修改某些数据，这是线程间通信的基础。

MessageQueue：消息队列

Android中的线程间通信涉及到四个组件:Handler,Looper,Message,MessageQueue

MessageQueue称为消息队列，得力于上文所述的ThreadLocal类，现在每一个线程可以拥有自己的MessageQueue了。MessageQueue通过一个单链表来维护一个消息队列，因为单链表在插入和删除过程中有性能优势。作为一个队列，它自然有两个方法，用于入队（插队）的enqueueMessage方法和出队的next方法

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

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

        msg.markInUse();
        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;
}

可以看到，enqueueMessage方法先检查Message的合法性，然后再根据Message的when属性将Message插入单链表中。

Message next() {
// Return here if the message loop has already quit and been disposed.
// This can happen if the application tries to restart a looper after quit
// which is not supported.
final long ptr = mPtr;
if (ptr == 0) {
return null;
}

    int pendingIdleHandlerCount = -1; // -1 only during first iteration
    int nextPollTimeoutMillis = 0;
    for (;;) {
        if (nextPollTimeoutMillis != 0) {
            Binder.flushPendingCommands();
        }

        nativePollOnce(ptr, nextPollTimeoutMillis);

        synchronized (this) {
            // Try to retrieve the next message.  Return if found.
            final long now = SystemClock.uptimeMillis();
            Message prevMsg = null;
            Message msg = mMessages;
            if (msg != null && msg.target == null) {
                // Stalled by a barrier.  Find the next asynchronous message in the queue.
                do {
                    prevMsg = msg;
                    msg = msg.next;
                } while (msg != null && !msg.isAsynchronous());
            }
            if (msg != null) {
                if (now < msg.when) {
                    // Next message is not ready.  Set a timeout to wake up when it is ready.
                    nextPollTimeoutMillis = (int) Math.min(msg.when - now, Integer.MAX_VALUE);
                } else {
                    // Got a message.
                    mBlocked = false;
                    if (prevMsg != null) {
                        prevMsg.next = msg.next;
                    } else {
                        mMessages = msg.next;
                    }
                    msg.next = null;
                    if (DEBUG) Log.v(TAG, "Returning message: " + msg);
                    msg.markInUse();
                    return msg;
                }
            } else {
                // No more messages.
                nextPollTimeoutMillis = -1;
            }

            // Process the quit message now that all pending messages have been handled.
            if (mQuitting) {
                dispose();
                return null;
            }

            // If first time idle, then get the number of idlers to run.
            // Idle handles only run if the queue is empty or if the first message
            // in the queue (possibly a barrier) is due to be handled in the future.
            if (pendingIdleHandlerCount < 0
                    && (mMessages == null || now < mMessages.when)) {
                pendingIdleHandlerCount = mIdleHandlers.size();
            }
            if (pendingIdleHandlerCount <= 0) {
                // No idle handlers to run.  Loop and wait some more.
                mBlocked = true;
                continue;
            }

            if (mPendingIdleHandlers == null) {
                mPendingIdleHandlers = new IdleHandler[Math.max(pendingIdleHandlerCount, 4)];
            }
            mPendingIdleHandlers = mIdleHandlers.toArray(mPendingIdleHandlers);
        }

        // Run the idle handlers.
        // We only ever reach this code block during the first iteration.
        for (int i = 0; i < pendingIdleHandlerCount; i++) {
            final IdleHandler idler = mPendingIdleHandlers[i];
            mPendingIdleHandlers[i] = null; // release the reference to the handler

            boolean keep = false;
            try {
                keep = idler.queueIdle();
            } catch (Throwable t) {
                Log.wtf(TAG, "IdleHandler threw exception", t);
            }

            if (!keep) {
                synchronized (this) {
                    mIdleHandlers.remove(idler);
                }
            }
        }

        // Reset the idle handler count to 0 so we do not run them again.
        pendingIdleHandlerCount = 0;

        // While calling an idle handler, a new message could have been delivered
        // so go back and look again for a pending message without waiting.
        nextPollTimeoutMillis = 0;
    }
}

next方法是一个无限循环的方法，如果MessageQueue队列中没有消息，此方法会堵塞，直到新的消息到来位置，它会将消息取出，然后再链表中删除它。

Looper:MessageQueue的使用者

有了消息队列之后，我们还需要一个使用消息队列的对象:Looper。从Looper的名字可以看出，它代表某种循环的意思。为了让某个线程能不断地处理消息(Message),我们就需要为线程创建Looper:

    Thread(
            {
                Looper.prepare()
                val handler = Handler()
                Looper.loop()
            }
    ).start()

注意这里需要调用Looper的静态方法。当然，我们也可以随时停止Looper，在线程中调用quit或者quitSatety即可:

                Looper.myLooper().quit()
                Looper.myLooper().quitSafely()

可以看到，Looper的主要方法都是静态方法，便于我们在线程的任意位置调用它们
Looper内部最重要的方法就是loop()方法，它是一个死循环，跳出循环的唯一方式是其MessageQueue的next返回了null（正常情况下应该是被堵塞的）。当Looper调用quit或者quitSafely时，它会通知消息队列退出，使其返回null值。
如果MessageQueue的next返回了Message消息，它会将这个消息交给Handler去处理。

Handler：消息的发送与处理者

Handler的工作就是发送消息和处理消息,它主要通过两个方法：sendMessage和post(runnable)去发送消息
它们的底层过程就是向消息队列中插入一条消息，通过Looper接收后又交给了它自己的dispatchMessage方法去处理:

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

首先，它会检查消息本身的callback是否为空（这适用于post方法发送的runnable对象消息），如果不为空则由这个runnable对象接管执行。
如果为空，再检查本Handler自身的mCallback是否为空，如果不为空则由这个对象代为处理。
如果mCallback也为空，则在自身的handleMessage方法中执行了，这是常规操作，自己在Handler的子类中实现这个方法即可

Handler还有一个很方便的构造方法，传入一个指定Looper来构造Looper:

public Handler(Looper looper) {
    this(looper, null, false);
}

比如 val handler = Handler(Looper.getMainLooper())，快速在其他线程中获取主线程的handler

作者：黑心石
链接：https://www.jianshu.com/p/8cb3c4f8978a
來源：简书
简书著作权归作者所有，任何形式的转载都请联系作者获得授权并注明出处。