飞奔的炮台 发表于 2022-4-13 12:19:51

Android的Handler线程切换原理

Handler是我们在开发中经常会接触到的类,因为在Android中,子线程一般是不能更新UI的.
所以我们会使用Handler切换到主线程来更新UI,那Handler是如何做到实现不同线程之间的切换呢?
先看一个例子
1.ThreadLocal的简单使用
public class HandlerActivity extends AppCompatActivity {
    private final static String TAG = "HandlerActivity";

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
      super.onCreate(savedInstanceState);
      setContentView(R.layout.activity_main);

    //1.创建一个ThreadLocal对象,
    final ThreadLocal<IThreadCallback> threadLocal = new ThreadLocal<>();
//对ThreadLocal赋值
    threadLocal.set(new IThreadCallback() {
    @Override
      public void onExecute() {
                Log.d(TAG,"当前线程:" + Thread.currentThread().getName());
    }
    });

//新开一个线程,并对threadLocal赋值
         Thread thread = new Thread(){
         @Override
public void run() {
             threadLocal.set(new IThreadCallback() {
             @Override
   public void onExecute() {
                  Log.d(TAG,"当前线程:" + Thread.currentThread().getName());
}
             });
   threadLocal.get().onExecute();
   }
      };

//获取IThreadCallback接口实例并执行onExecute()方法
threadLocal.get().onExecute();

thread.setName("otherThread");
//开启线程,并在线程内部获取IThreadCallback接口实例并执行onExecute()方法
thread.start();
    }

    //定义了一个回调接口
    public interface IThreadCallback{
      void onExecute();
    }
}

可以看到,我们总共调用了两次set()方法,而执行的线程也是在不同线程下,所以,Handler是通过ThreadLocal来
进行线程切换的.那么ThreadLocal是怎么做到的呢?
2.ThreadLocal的原理
首先我们先看看ThreadLocal.set()方法做了什么,我们一行一行代码来看
public void set(T value) {
    //获取当前方法(set方法)所执行的线程
    Thread t = Thread.currentThread();

    //getMap() ====> t.threadLocals,它是Thread类中定义的一个成员变量,也就是说
    //每一个线程都一个独一无二的threadLocals,它是一个ThreadLocal.ThreadLocalMap类型,
    //它是ThreadLocal的内部类
    ThreadLocalMap map = getMap(t);

    if (map != null)
//直接将value和当前ThreadLocal绑定
      map.set(this, value);
    else
//为空则会直接new ThreadLocalMap(this, value);
      createMap(t, value);
}
getMap() ====> t.threadLocals,它是Thread类中定义的一个ThreadLocal.ThreadLocalMap对象,
ThreadLocalMap是ThreadLocal的一个内部静态类,如果map不为空,它就会调用set方法把我们传进来的
对象封装成了一个Entry对象,并保存到Entry[]数组中
private void set(ThreadLocal<?> key, Object value) {

    Entry[] tab = table;
    int len = tab.length;
    int i = key.threadLocalHashCode & (len-1);

    ...
    ...
    //new了一个Entry()对象,也是ThreadLocal的内部静态类
    //内部有一个Object类型的成员变量,用来保存我们传进来的值
    tab = new Entry(key, value);
    ...
    ...
}
get()方法
public T get() {
   //获取当前方法(get方法)所在线程
    Thread t = Thread.currentThread();
   
    ThreadLocalMap map = getMap(t);
    if (map != null) {
//从Entry[] table数组中去获取保存的值
      ThreadLocalMap.Entry e = map.getEntry(this);
      if (e != null) {
            @SuppressWarnings("unchecked")
   
    //将我们传进来的value强转为T所表示的类型,这个value就是对应线程的对象了
            T result = (T)e.value;
            return result;
}
    }
    return setInitialValue();
}
上面大抵描述了一个ThreadLocal的基本流程,就算你还是看不懂、理解不了也没关系,
你只要知道,你在哪个线程中调用set方法,那么那个对象就属于那个线程,因为每个线程是有一块自己的
内存区域,在线程中定义的变量,都会存在于当前线程自己的内存区域.
比如:
//这是在主线程初始化,new的实例,那它就存在于主线程的内存区域
threadLocal.set(new IThreadCallback() {
    @Override
    public void onExecute() {
      Log.d(TAG,"当前线程:" + Thread.currentThread().getName());
    }
});
Thread thread = new Thread(){
   @Override
   public void run() {
//不在主线程,所以new IThreadCallback()
         //它是保存在当前线程(otherThread),还记得吗,我们给它
         //设置了一个名称otherThread
         threadLocal.set(new IThreadCallback() {
         @Override
         public void onExecute() {
             Log.d(TAG,"当前线程:" + Thread.currentThread().getName());
         }
      });
      threadLocal.get().onExecute();
    }
};
3.Handler的UI线程切换原理
在知道了ThreadLocal的使用原理之后,其实就很简单了,跟我们上面的例子类似.
我们知道,在子线程(非UI线程)中创建Handler会报错.

解决方法也很简单,只要在创建Handler之前,调用Looper.prepare()方法就不会报错了,
我们看一下Looper.prepare()做了什么
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的内部有一个ThreadLocal的实例sThreadLocal,调用prepare()方法会直接new Looper()对象,将Looper对象通过ThreadLocal绑定到相应的线程,这样Looper中所有执行的方法和变量都在对应的线程中,达到不同线程之间切换的效果.Looper类是Handler能完成消息发送的一个重要成员,在创建了Handler之后,调用Looper.loop()就能进行消息循环,内部有一个死循环不断会从消息队列中去取Message,按照先后顺序依次调用Message.target.dispatchMessage()方法,最后调用到handleMessage()方法,Message.target是一个Handler类型的对象,它在sendMessage()的时候被赋值.
我们可以在子线程中尝试使用Toast,如果不调用Looper.loop()方法,在以前版本的系统上,Toast是不会显示,必须要调用Looper.loop()进行消息循环才能显示.Android11不调用也能显示,应该是内部帮我们调用了.
handleMessage之所以能执行在主线程,是因为Loop对象本身就是在主线程创建的.有人会说,我又没有调用Looper.prepare()方法,它为什么不报错呢,因为主线程的Looper对象已经在ActivityThread.main方法中
已经调用过了,所以我们不需要调用Looper.prepare()就能使用.如果要获取主线程的Looper对象,可以调用Looper.getMainLooper()方法获取,可以利用这个Looper对象来创建一个Handler对象,让它的HandleMessage方法执行在主线程.


   
   
   
                        

https://www.cnblogs.com/komine/p/16127223.html
页: [1]
查看完整版本: Android的Handler线程切换原理