一、Thread Local Storage 模式

1. ThreadLocal 的使用

Thread Local Storage 表示线程本地存储模式。

大多数并发问题都是由于变量的共享导致的，多个线程同时读写同一变量便会出现原子性，可见性等问题。局部变量是线程安全的，本质上也是由于各个线程各自拥有自己的变量，避免了变量的共享。

Java 中使用了 ThreadLocal 来实现避免变量共享的方案。ThreadLocal 保证在线程访问变量时，会创建一个这个变量的副本，这样每个线程都有自己的变量值，没有共享，从而避免了线程不安全的问题。

下面是 ThreadLocal 的一个简单使用示例：

public class ThreadLocalTest {
    private static final ThreadLocal<SimpleDateFormat> threadLocal =
            ThreadLocal.withInitial(() -> new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"));
    public static SimpleDateFormat safeDateFormat() {
        return threadLocal.get();
    }
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        FutureTask<SimpleDateFormat> task1 = new FutureTask<>(ThreadLocalTest::safeDateFormat);
        FutureTask<SimpleDateFormat> task2 = new FutureTask<>(ThreadLocalTest::safeDateFormat);
        Thread t1 = new Thread(task1);
        Thread t2 = new Thread(task2);
        t1.start();
        t2.start();
        System.out.println(task1.get() == task2.get());//返回false，表示两个对象不相等
    }
}

程序中构造了一个线程安全的 SimpleDateFormat ，两个线程取到的是不同的示例对象，这样就保证了线程安全。

2. ThreadLocal 原理浅析

线程 Thread 类内部有两个 ThreadLocalMap 类型的变量：

/* ThreadLocal values pertaining to this thread. This map is maintained
 * by the ThreadLocal class. */
ThreadLocal.ThreadLocalMap threadLocals = null;
/*
 * InheritableThreadLocal values pertaining to this thread. This map is
 * maintained by the InheritableThreadLocal class.
 */
ThreadLocal.ThreadLocalMap inheritableThreadLocals = null;

其中第二个变量的用途是创建可继承父线程变量的子线程，只不过这并不常用，主要介绍第一个。

ThreadLocalMap 是一个用于存储 ThreadLocal 的特殊 HashMap，map 中 key 就是 ThreadLocal，value 是线程变量值。只不过这个 map 并不被 ThreadLocal 持有，而是被 Thread 持有。

当调用 ThreadLocal 类中的 set 方法时，就会创建 Thread 中的 threadLocals 属性。

//ThreadLocal的set方法
public void set(T value) {
    Thread t = Thread.currentThread();
    ThreadLocalMap map = getMap(t);//获取Thread中的ThreadLocalMap
    if (map != null)
        map.set(this, value);
    else
        createMap(t, value);
}

可以看到，最终的 ThreadLocal 对象和变量值并不是创建在 ThreadLocal 内部，而是 Thread 中的 ThreadLocalMap，ThreadLocal 在这里只是充当了代理的作用。

3. ThreadLocal 内存泄漏问题

存储数据的 TheadLocalMap 被 Thread 持有，而不是 ThreadLocal，主要的原因便是 ThreadLocal 的生命周期比 Thread 要长，如果 ThreadLocal 对象一直存在，那么 map 中的线程就不能被回收，容易导致内存泄漏。

而 Thread 持有 ThreadLocalMap，并且 ThreadLocalMap 对 ThreadLocal 的引用还是弱引用，这样当线程被回收时，map 也能够被回收，更加安全。

但是 Java 的这种设计并没有完全避免内存泄漏问题。如果线程池中的线程存活时间过长，那么其持有的 ThreadLocalMap 一直不会被释放。ThreadLocalMap 中的 Entry 对其 value 是强引用的（对 ThreadLocal 是弱引用），这样就算 ThreadLocalMap 的生命周期结束了，但是 value 值并没有被回收。

解决的办法便是手动释放 ThreadLocalMap 中对 value 的强引用，可以使用 TheadLocal 的 remove 方法。在 finally 语句块中执行。例如下面这个简单的示例：

public class ThreadLocalTest {
    private final ThreadLocal<Integer> threadLocal = new ThreadLocal<>();
    public void test(){
        //设置变量值
        threadLocal.set(10);
        try {
            System.out.println(threadLocal.get());
        }
        finally {
            //释放
            threadLocal.remove();
        }
    }
}

二、Immutability 模式

1. 不可变的概念

Immutability，即不变模式。可以理解为只要对象一经创建，其状态是不能够被改变的，无法进行写操作。

要实现 Immuatability 模式很简单，将一个类本身及其所有的属性都设为 final ，并且方法都是只读的，需要注意的是，如果类的属性也是引用类型，那么其对应的类也要满足不可变的特性。final 应该都很熟悉了，用它来修饰类和方法，分别表示类不可继承、属性不可改变。

Java 中具备不可变性的类型包括：

• String
• final 修饰的基本数据类型
• Integer、Long、Double 等基本数据类型的包装类
• Collections 中的不可变集合

具备不可变性的类，如果需要有类似修改这样的功能，那么它不会像普通的对象一样改变自己的属性，而是创建新的对象。

下面是 String 的字符串连接方法 concat() 的源码，仔细观察，可以看到最后方法返回的时候，创建了一个新的 Sring 对象：

public String concat(String str) {
    int otherLen = str.length();
    if (otherLen == 0) {
        return this;
    }
    int len = value.length;
    char buf[] = Arrays.copyOf(value, len + otherLen);
    str.getChars(buf, len);
    //创建新的对象
    return new String(buf, true);
}

而 Collections 工具可以将集合变为不可变的，完全禁止写、修改等操作。示例如下：

//Collections 中构建不可变集合的方法

Collections.unmodifiableList();

Collections.unmodifiableSet();

Collections.unmodifiableMap();

Collections.unmodifiableSortedSet();

Collections.unmodifiableSortedMap();

---

List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);

//构建不可变集合

List<Integer> unmodifiableList = Collections.unmodifiableList(list);

unmodifiableList.remove(1);//抛出异常

2. 对象池

对于一个不可变性的类，如果频繁的对其进行修改操作，那么一直会创建性新的对象，这样就比较浪费内存空间了，一种解决办法便是利用对象池。

原理也很简单，新建对象的时候，去对象池看是否存在对象，如果存在则直接利用，如果不存在才会创建新的对象，创建之后再将对象放到对象池中。

以长整型的包装类 Long 为例，它缓存了 -128 到 127 的数据，如果创建的是这个区间的对象，那么会直接使用缓存中的对象。例如 Long 中的 valueOf 方法就用到了这个缓存，然后直接返回：

public static Long valueOf(long l) {
    final int offset = 128;
    //在这个区间则直接使用缓存中的对象
    if (l >= -128 && l <= 127) { // will cache
        return LongCache.cache[(int)l + offset];
    }
    return new Long(l);
}