前面我们介绍了 对象的可见性和发布与逸出，确保对象的可见性可以通过加锁以及volatile关键字实现；对象发布则要求我们确保合理安全的封装。参考：第三章 对象的共享（一） - 简书。
3.3 线程封闭
当访问共享的可变数据时，通常需要使用同步。一种避免使用同步的方式就是不共享数据。如果仅在单线程内访问数据，就不需要同步。这种技术称为线程封闭（Thread Confinement）。它是实现线程安全性最简单的方式。
此处我们提供一种最为有效规范的线程封闭方式------java.lang.ThreadLocal 类。
ThreadLocal对象通常用于防止对可变的单实例变量（Singleton）或全局变量进行共享。
例如，在单线程应用程序中可能会维持一个全局的数据库连接，并在程序启动时初始化这个连接对象，从而避免在调用每个方法时都要传递一个Connection对象。但由于JDBC的连接对象不一定是线程安全的，因此，在多线程应用程序中，在没有协同的情况下使用这个Connection全局变量是不安全的。这时我们可将JDBC的连接对象保存到ThreadLocal对象中，这样每个线程都会拥有自己的单独的连接，就保证了线程安全。
public class ConnectionManager{
private static ThreadLocal<Connection> connectionHolder=new ThreadLocal<>(){
public Connection initialValue(){
Connection conn =null;
try{
conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/test","username","password");
}catch(SQLException e) {
e.printStackTrace();
}
return con;
}
}；
public Connection getConnection(){
return connectionHolder.get();
}
public void set(Connection con){
connectionHolder.set(con);
}
}
当某个线程初次调用ThreadLocal .get() 方法时，就会调用initialValue 来获得初始值。从概念上看，你可将Threadlocal<T>视为Map<Thread,T>对象，其中保存了特定于该线程的值。
当某个频繁执行的操作需要一个临时对象，例如一个缓冲区，就可以使用这项技术。例如，在Java 5.0之前，Integer.toString()方法使用了ThreadLocal对象来保存一个12字节大小的缓冲区，用于对结果格式化。而不是使用共享的静态缓冲区（这需要加锁）或者在每次调用时都分配一个新的缓冲区。
更多关于ThreadLocal对象的知识，请参考我的另一篇文章：深入剖析 java.lang.ThreadLocal 类 - 简书 。
3.4 不变性
满足同步需求的另一种方法是使用不可变对象（Immutable Object）。
如果某个对象在创建后其状态不能被修改，那么这个对象就称作不可变对象。线程安全性是不可变对象的固有属性之一。
不可变对象很简单，他们只有一种状态并且该状态由构造函数来控制。
当满足以下条件时，对象才是不可变的：
（1）对象创建后其状态就是不可修改的。
（2）对象所有的域都是final 类型的。
（3）对象是被正确创建的（在对象的创建期间，this引用没有逸出）。
程序：在可变对象基础上构建不可变类：
@Immutable
public final class ThreeStooges{
private final Set<String> stooges = new HashSet<String> ();
public ThreeStooges(){
stooges.add("Moe");
stooges.add("Larry");
stooges.add("Curry");
}
public boolean isStooge(String name){
return stooges.contains(name);
}
}
示例：使用Volatile 类型来发布不可变对象
程序清单：对数值及其因数分解结果进行缓存的不可变类容器
@Immutable
class OneValueCache {
private final BigInteger lastNumber;
private final BigInteger[] lastFactors;
public OneValueCache(BigInteger i,
BigInteger[] factors) {
lastNumber=i;
lastFactors=Arrays.copyOf(factors, factors.length);
}
public BigInteger[] getFactors(BigInteger i) {
if (lastNumber== null || !lastNumber.equals(i))
return null;
else
return Arrays.copyOf(lastFactors, lastFactors.length);
}
}
对于在访问和更新多个相关变量时出现的竞争条件问题，可以通过将这些变量全部保存在一个不可变对象中来消除。如果是一个可变的对象，那么就必须使用锁来确保原子性。如果是一个不可变对象，那么当线程获得了对该对象的引用后，就不必担心另一个线程会修改对象的状态。如果要更新这些变量，那么可以创建一个新的容器对象，但其他使用原有对象的线程仍然会看到对象处于一致的状态。
程序清单3-13中的VolatileCachedFactorizer使用了OneValueCache来保存缓存的数值及其因数。当一个线程将volatile类型的cache设置为引用一个新的OneValueCache时，其他线程就会立即看到新缓存的数据。
程序清单 3-13 使用指向不可变容器对象的volatile类型引用以缓存最新的结果
@ThreadSafe
public class VolatileCachedFactorizer implements Servlet {
private volatile OneValueCachecache=
newOneValueCache(null, null);
public void service(ServletRequest req, ServletResponse resp) {
BigIntegeri=extractFromRequest(req);
BigInteger[]factors=cache.getFactors(i);
if (factors== null) {
factorfactors= factor(i);
cache=newOneValueCache(i, factors);
}
encodeIntoResponse(resp, factors);
}
}
与cache相关的操作不会相互干扰，因为OneValueCache是不可变的，并且在每条相应的代码路径中只会访问它一次。通过使用包含多个状态变量的容器对象来维持不变性条件，并使用一个volatile类型的引用来确保可见性，使得Volatile Cached Factorizer在没有显式地使用锁的情况下仍然是线程安全的。
