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[i] = 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方法执行在主线程.