常见在主线程(UI线程)更新UI。
public class MainActivity extends Activity {
private Handler handler = new Handler() {
// 处理子线程给我们发送的消息。
//注意：handler并没有处理耗时操作的能力，使用handler的目的只是完成耗时操作以后，给个通知(带个数据)去触发下面的操作。
@Override
public void handleMessage(android.os.Message msg) {
byte[] data = (byte[])msg.obj;
Bitmap bitmap = BitmapFactory.decodeByteArray(data, 0, data.length);
imageView.setImageBitmap(bitmap);
};
};
public class MyThread implements Runnable{
// 在run方法中完成网络耗时的操作
@Override
public void run() {
byte[] data = EntityUtils.toByteArray(httpResponse.getEntity());
// 耗时操作是另外一个线程，和主线程是异步的，想让主线成知道你什么时候完成了操作，用handler通知主线程。
// 注意：这个msg的目的时通知主线程的handler，所以必须用主线程的handler发送信息，而不是new出来的handler。
Message message = Message.obtain();
message.obj = data;
message.what = DOWNLOAD_IMG;
handler.sendMessage(message);
}
}
}
注意：handler并没有处理耗时操作的能力，使用handler的目的只是完成耗时操作以后，给个通知(带些数据)去触发下面的操作。
在子线程中 new Handler()
//Google推荐写法。其它写法我特么也不知道啊。
class LooperThread extends Thread {
public Handler mHandler;
public void run() {
Looper.prepare();
mHandler = new Handler() {
public void handleMessage(Message msg) {
// 处理hander信息
}
};
Looper.loop();
}
}
在Activity中生成的handler没有prepare是因为：UI线程是主线程,系统已经自动帮我们调用了Looper.prepare()方法.
如果没有Looper.prepare()的话，会抛异常:"Can't create handler inside thread that has not called Looper.prepare()"。
一步一步分析：
1.先介绍ThreadLoacal和Thread的关系：
- 通常情况下，我们创建的变量是可以被任何一个线程访问并修改的。而使用ThreadLocal创建的变量只能被当前线程访问，其他线程则无法访问和修改。
- TheadLocal类中定义了一个ThreadLocalMap类，ThreadLocalMap类中定义了一个Entry类，并且有一个长度为16的Entry数组。Entry类每次把ThreadLocal的实例和对应值保存起来，Entry不是map，只是维护了一个key-value的值。
- Thead类中，有一个ThreadLocalMap类的引用。也就是每个线程，能保存16个ThreadLocal实例和值的对应关系。
- 资料
//ThreadLocal类，看set方法如何给thread设置对应值
//value就是传入的要和Thread对应的值，例如：Looper对象。
public void set(T value) {
Thread t = Thread.currentThread();
//获得该thread中的map对象
ThreadLocalMap map = getMap(t);
//拿到Thread中的map对象，把要对应的值设置到map中。实际上，是设置到了map中的Entry类中。
if (map != null)
map.set(this, value);
else
createMap(t, value);
}
//拿到的是当前thread中的map对象
ThreadLocalMap getMap(Thread t) {
return t.threadLocals;
}
//当前Thread如果没有的话，就设置一个新的map
void createMap(Thread t, T firstValue) {
t.threadLocals = new ThreadLocalMap(this, firstValue);
}
//每个ThreadLocalMap生成实例的时候，初始化一个长度为16的Entry数组。
ThreadLocalMap(ThreadLocal firstKey, Object firstValue) {
table = new Entry[16];
//threadLocal作为脚标
int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
table[i] = new Entry(firstKey, firstValue);
size = 1;
}
//实际上对应的值，设置到了Entry的value属性上
static class Entry extends WeakReference<ThreadLocal> {
/** The value associated with this ThreadLocal. */
Object value;
Entry(ThreadLocal k, Object v) {
super(k);
value = v;
}
}
通过ThreadLoacal给Thread设置值的流程是：在thread拿到或生成新的 threadLocalMap，以threadLoacal的hash值作为脚标找到Entry，设置value。
//再看ThreadLoacal的get方法。
public T get() {
Thread t = Thread.currentThread();
ThreadLocalMap map = getMap(t);
if (map != null) {
//获得当前thread中map对象的entry对象的value属性，即存入的对应值。
ThreadLocalMap.Entry e = map.getEntry(this);
if (e != null)
return (T)e.value;
}
//如果e == null，没有设置过对应值。这给Thread设置个map，返回null。
/**
*看下面方法，Looper.preaper()方法，调用了set设置对应的Looper。
*所以，没有调用Looper.preaper()时，new Handler()中mLooper = Looper.myLooper()-->sThreadLocal.get()得到的是null。
*/
return setInitialValue();
}
private T setInitialValue() {
T value = null;
Thread t = Thread.currentThread();
ThreadLocalMap map = getMap(t);
if (map != null)
map.set(this, value);
else
createMap(t, value);
return value;
}
通过ThreadLocal获得Thread对应值流程：在thread拿到map，已threadLocal的hash值作为脚标找到数组中对应的Entry，取出value。
总的来说，通过ThreadLocal获取／设置Thread的对应值的流程为：thread拿到或生成threadLocalMap，通过threadLocal的hash值(不知道是什么的hashCode)对应的脚标，生成Entry放入对应值到value，Entry放入数组。
Entry中key相当于是threadLocal的实例对象，且是弱引用。没研究具体原理。
2.先看有preaper()时，为什么new Handler()能得到Looper对象。看看preaper()做了什么：
private static void prepare(boolean quitAllowed) {
if (sThreadLocal.get() != null) {
throw new RuntimeException("Only one Looper may be created per thread");
}
//设置Looper到Thread
sThreadLocal.set(new Looper(quitAllowed));
}
//ThreadLocal的set方法，把looper设置到thread中的map对象中。
public void set(T value) {
Thread t = Thread.currentThread();
ThreadLocalMap map = getMap(t);
if (map != null)
map.set(this, value);
else
createMap(t, value);
}
3.没有preaper()时
public Handler(Callback callback, boolean async) {
mLooper = Looper.myLooper();
//这里得到null，所以报错。
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;
}
//Looper里的方法
public static @Nullable Looper myLooper() {
return sThreadLocal.get();
}
//ThreadLocal里的方法
//没有preaper把looper设置到thread中的map的entry中，所以得到的value为null。
public T get() {
Thread t = Thread.currentThread();
ThreadLocalMap map = getMap(t);
if (map != null) {
ThreadLocalMap.Entry e = map.getEntry(this);
if (e != null)
return (T)e.value;
}
return setInitialValue();
}
private T setInitialValue() {
T value = null;
Thread t = Thread.currentThread();
ThreadLocalMap map = getMap(t);
if (map != null)
map.set(this, value);
else
createMap(t, value);
return value;
}
Thread,Looper,MessageQueue三者一一对应：
1.如果Thread中已经有了Looper对象，再preaper的时候，!=null会报错。一个Looper只能对应一个Thread。
2.MessageQueue在Looper中，Looper在Thread的map对象中。
为什么说使用ThreadLocal创建的变量只能被当前线程访问，其他线程则无法访问和修改呢？
既然这个map是Thread自己的，又可以被外界访问，为什么不能被其它线程修改？threadLocalMap只是Thread中的一个变量，是可以修改的。只是说，不同的线程，同一个threadLocal对象，操作set/get方法时，各个线程只能修改自己的那一份value对应值。
例如：
//Looper中，sThreadLocal是一个static 并且final的变量，从Looper类加载的时候就已经存在了。无论哪个线程访问Looper中的threadLocal都是该变量。
//另外：泛型类，已经声明为Looper，也就是set／get确定操作的对应值为Looper类。
static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>();
所以，不同的线程，操作Looper.prepear,都是在各自的线程set/get操作Looper，互不干扰。
