最早接触到ThreadLocal是在阅读dianping的Cat-client，当时对它不是很理解，就搜索了一下，大概了解是一种解决线程安全问题的机制。现在再次阅读《实战java高并发程序设计》时，又重新对它有了更深一步的了解。

并发程序很重要的主题就是解决多线程安全的问题，最常见的处理办法就是引入锁的机制；但是锁使得各个线程对临界区的使用效率变差，于是有了一种新的思路，即每个线程独立管理某个变量，变量的修改在线程中时独立的。就好比，以前锁的机制是100个人签到，只有一个签字薄；而现在ThreadLocal是每个人一张纸。

不过上面的场景，只是threadLocal的一个应用场景。还有个例子，是在城市里面倒车。小明去上班要先做公交车在做地铁，如果每次坐车都买票，那么时间效率很差。于是小明办理了一张通用的公交卡，公交车和地铁都可以刷。而小蓝小红也有这样的公交卡，它们的公交卡彼此之间是独立的。这就是ThreadLocal的作用！

所以说，ThreadLocal并不是解决线程共享问题，而是为了解决单个线程内部变量的独立性和参数传递的问题。

那么它的原理时什么样的呢？

说白了，就是每个线程自己有一个Map，这个Map采用了线性探测法来存储变量。接下来主要阅读下代码吧:

public T get() {

    Thread t = Thread.currentThread();

    // 获取当前线程的localmap

    ThreadLocalMap map = getMap(t);

    if (map != null) {

        // 用当前的变量作为key查询对象

        ThreadLocalMap.Entry e = map.getEntry(this);

        if (e != null) {

            @SuppressWarnings("unchecked")

            T result = (T)e.value;

            return result;

        }

    }

    // 如果不存在的话，初始化变量

    return setInitialValue();

}

public void set(T value) {

    Thread t = Thread.currentThread();

    ThreadLocalMap map = getMap(t);

    if (map != null)

        map.set(this, value);

    else

        createMap(t, value);

}

主要时那个getEntry方法:

private Entry getEntry(ThreadLocal<?> key) {

    // 通过当前key的hashcode与列表的长度做 &操作，判断存储的位置

    int i = key.threadLocalHashCode & (table.length - 1);

    Entry e = table[i];

    if (e != null && e.get() == key)

        return e;

    else

        // 如果不存在的话，进入getEntryAfterMiss方法

        // 这种情况，可能是key被回收掉了；也可能是hash冲突了

        return getEntryAfterMiss(key, i, e);

}

private Entry getEntryAfterMiss(ThreadLocal<?> key, int i, Entry e) {

            Entry[] tab = table;

            int len = tab.length;

// 这里是典型的线性地址探测法

            while (e != null) {

                ThreadLocal<?> k = e.get();

                if (k == key)

                    return e;

                if (k == null)

                    expungeStaleEntry(i);

                else

                    i = nextIndex(i, len);

                e = tab[i];

            }

            return null;

        }

需要注意的是，ThreadLocal里面的内存结构是这样的:

由于key是弱引用，因此在gc的时候会被回收掉。所以entry中会包含key为null的值，那么这里会不会有内存泄漏呢？可以看一下expungeStaleEntry方法，在发现有value为null的时候，threadlocal会自动扫描其他的元素，看看有没有key为null的，如果有的话，一并移除。

如果为null，需要清理对应的value：

private int expungeStaleEntry(int staleSlot) {

    Entry[] tab = table;

    int len = tab.length;

    // expunge entry at staleSlot

    tab[staleSlot].value = null;

    tab[staleSlot] = null;

    size--;

    // Rehash until we encounter null

    Entry e;

    int i;

    for (i = nextIndex(staleSlot, len);

         (e = tab[i]) != null;

         i = nextIndex(i, len)) {

        ThreadLocal<?> k = e.get();

        if (k == null) {

            e.value = null;

            tab[i] = null;

            size--;

        } else {

            int h = k.threadLocalHashCode & (len - 1);

            if (h != i) {

                tab[i] = null;

                // Unlike Knuth 6.4 Algorithm R, we must scan until

                // null because multiple entries could have been stale.

                while (tab[h] != null)

                    h = nextIndex(h, len);

                tab[h] = e;

            }

        }

    }

    return i;

}

官方推荐使用private static修饰，跟Java大神聊了下，总结一下ThreadLocal为什么推荐这样使用：

推荐用private修饰，是不向外部其他的对象也能引用到，防止干扰垃圾回收
推荐使用static，我个人的理解是为了把对象存储到方法去（static修饰的变量会存储在方法区），这样虽然内部的Entry是弱引用，但由于变量在方法区，也不会在gc的时候被回收掉。<---个人理解哈，如有不对，还请指正

应用

在cat的代码中:

public class DefaultMessageManager extends ContainerHolder implements MessageManager, Initializable, LogEnabled {

    // we don't use static modifier since MessageManager is configured as singleton

	private ThreadLocal<Context> m_context = new ThreadLocal<Context>();

    // 每个线程拥有独立的上下文信息

    private Context getContext() {

		if (Cat.isInitialized()) {

			Context ctx = m_context.get();

			if (ctx != null) {

				return ctx;

			} else {

				if (m_domain != null) {

					ctx = new Context(m_domain.getId(), m_hostName, m_domain.getIp());

				} else {

					ctx = new Context("Unknown", m_hostName, "");

				}

				m_context.set(ctx);

				return ctx;

			}

		}

		return null;

	}

    @Override

	public void end(Transaction transaction) {

		Context ctx = getContext();

		if (ctx != null && transaction.isStandalone()) {

			if (ctx.end(this, transaction)) {

				m_context.remove();

			}

		}

	}

巴特西

ThreadLocal从源码到应用

应用

最新文章

热门文章