Handler的终结者

消息循环:


Handler的终结者_第1张图片

总结

  1. 当一个Android应用启动时,框架会分配到一个Looper实例给应用的主线程。这个Looper的主要工作就是处理一个接着一个的消息对象。在Android中,所有Android框架的事件(比如Activity的生命周期方法的调用和按钮的点击等)都是放到消息中,然后加入到Looper要处理的消息队列中,由Looper依次处理。主线程的Looper的生命周期和应用的一样长。
  • 当在主线程中初始化一个Handler时,它就会关联到Looper的消息队列。发送到消息队列的消息本身就持有Handler的引用,只有这样Looper在处理这个条消息的时候才能调用Handler#handleMessage(Message)处理消息。
public Handler(Callback callback, boolean async) {
    ...

    mLooper = Looper.myLooper();
    if (mLooper == null) {
        throw new RuntimeException(
            "Can't create handler inside thread that has not called Looper.prepare()");
    }
    mQueue = mLooper.mQueue;
    mCallback = callback;
    mAsynchronous = async;
}

在Handler发送消息的时候,会把消息插入到Handler初始化关联的Looper的消息队列中,并且msg消息本身就持有了Handler的引用。

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

在Looper初始化的时候,Looper会初始化对应Looper的MessageQueue.并把Looper放入ThreadLocal中

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));
}
private Looper(boolean quitAllowed) {
    mQueue = new MessageQueue(quitAllowed);
    mThread = Thread.currentThread();
}
  • Android没有全局的消息队列,消息队列是和某个线程相关联在一起的。每个线程最多有一个消息队列,消息的取出和处理,也在这个线程本身中完成。每个线程在创建自己的消息队列之前都应该调用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));
}

那么如何获取到当前线程的Looper,答案就在 ThreadLocal


问题

  1. Handler是属于哪个类的?

Handler属于Activity,创建任何一个Handler都属于重写了Activity中的Handler。

  1. Handler、Looper、MessageQueue何时建立的相互关系?

在Handler的构造中,默认完成了对当前线程Looper的绑定.

  1. 主线程的Looper和MessageQueue是何时创建的?
    在Android中,ActivityThread的main方法是程序的入口,主线程的Looper和MessageQueue就是在此时创建的。


    Handler的终结者_第2张图片
  2. 在同一线程中,Looper和MessageQueue是怎样的数量对应关系,与Handler又是怎样的数量对应关系?

  3. MessageQueue 中消息为空,线程阻塞挂起等待,为什么不会造成ANR?

  4. 有关Handler的内存泄漏是怎么一回事?Handler可能造成内存泄漏(四)
    在Java中,非静态的内部类或者匿名类会隐式的持有其外部类的引用,而静态的内部类则不会。

Handler定义的模板

public class SampleActivity extends Activity {

  /**
   * Instances of static inner classes do not hold an implicit
   * reference to their outer class.
   */
  private static class MyHandler extends Handler {
    private final WeakReference mOutter;

    public MyHandler(SampleActivity activity) {
      mOutter= new WeakReference(activity);
    }

    @Override
    public void handleMessage(Message msg) {
      SampleActivity activity = mOutter.get();
      if (activity != null) {
        // ...
      }
    }
  }

  private final MyHandler mHandler = new MyHandler(this);

  /**
   * Instances of anonymous classes do not hold an implicit
   * reference to their outer class when they are "static".
   */
  private static final Runnable sRunnable = new Runnable() {
      @Override
      public void run() { /* ... */ }
  };

  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);

    // Post a message and delay its execution for 10 minutes.
    mHandler.postDelayed(sRunnable, 1000 * 60 * 10);

    // Go back to the previous Activity.
    finish();
  }
}

ThreadLocal的工作原理

示例引入
final ThreadLocal mBooleanThreadLocal = new ThreadLocal<>();
mBooleanThreadLocal.set(true);
Log.d(TAG,"[main]mBooleanThreadLocal="+mBooleanThreadLocal.get());                  //true

new Thread("Thread#1"){
    @Override
    public void run(){
        mBooleanThreadLocal.set(false);
        Log.d(TAG,"[Thread#1]mBooleanThreadLocal="+mBooleanThreadLocal.get());      //false
    }
}.start();

new Thread("Thread#2"){
    @Override
    public void run(){
        Log.d(TAG,"[Thread#2]mBooleanThreadLocal="+mBooleanThreadLocal.get());      //null
    }
}.start();

结果

Paste_Image.png

也就是说, ThreadLocal保存的数据仅仅与当前的线程有关。其用于线程间无影响的修改数据。下面分析其原理

Looper 的prepare会向ThreeadLocal 中插入当前的线程的Looper对象

static final ThreadLocal sThreadLocal = new ThreadLocal();

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

看看ThreadLocal的set方法

public void set(T value) {
    Thread currentThread = Thread.currentThread();
    Values values = values(currentThread);
    if (values == null) {
        values = initializeValues(currentThread);
    }
    values.put(this, value);
}

首先通过values方法获取到当前线程的ThreadLocal数据。Thread类中有个专门用来存储线程的 ThreadLocal 数据:ThreadLocal.Values localValues. 如果localValues值为null,则进行初始化。在localValues内部有一个数组:private Object[] table,ThreadLocal 的值就存在这个数组中.

void put(ThreadLocal key, Object value) {
        cleanUp();

        // Keep track of first tombstone. That's where we want to go back
        // and add an entry if necessary.
        int firstTombstone = -1;

        for (int index = key.hash & mask;; index = next(index)) {
            Object k = table[index];

            if (k == key.reference) {
                // Replace existing entry.
                table[index + 1] = value;
                return;
            }

            if (k == null) {
                if (firstTombstone == -1) {
                    // Fill in null slot.
                    table[index] = key.reference;
                    table[index + 1] = value;
                    size++;
                    return;
                }

                // Go back and replace first tombstone.
                table[firstTombstone] = key.reference;
                table[firstTombstone + 1] = value;
                tombstones--;
                size++;
                return;
            }

            // Remember first tombstone.
            if (firstTombstone == -1 && k == TOMBSTONE) {
                firstTombstone = index;
            }
        }
    }

暂且不分析他的具体算法,我们得出一个存储规则,那就是ThreadLocal的值在 table 数组中的存储位置总之那个是 ThreadLocal 的 reference 字段所标识的对象的下一个位置。

再来看 ThreadLocal 的get方法

public T get() {
    // Optimized for the fast path.
    Thread currentThread = Thread.currentThread();
    Values values = values(currentThread);
    if (values != null) {
        Object[] table = values.table;
        int index = hash & values.mask;
        if (this.reference == table[index]) {
            return (T) table[index + 1];
        }
    } else {
        values = initializeValues(currentThread);
    }

    return (T) values.getAfterMiss(this);
}

可以得出 ThreadLocal 的 set 和 get 方法操作的都是当前线程的 localValues 对象的 Table 数组,因此在不同线程中访问同一个 ThreadLocal 的 set 和 get方法,他们对 ThreadLocal 所做的读/写仅限于各自的线程的内部。

你可能感兴趣的:(Handler的终结者)