1 public class NoVisibility{ 2    private static boolean ready; 3    private static int number; 4    private static class ReaderThread extends Thread{ 5          public void run(){ 6                while(!ready) 7                      Thread.yield(); 8                System.out.println(number); 9          }10    }11 12     public static void main(String[] args){13            new ReaderThread().start();14            number = 42;15            ready = true;16     }17 }

1 @NotThreadSafe2 public class MutableInteger{3       private int value;4       public int get(){return value;}5       public void set(int value){this.value =http://www.mamicode.com/ value;} 6 }      

@ThreadSafe public class SynchronizedInteger{       @GuardBy("this") private int value;       public synchronized int get(){return value;}       public synchronized void set(int value){this.value =http://www.mamicode.com/ value;}}

volatile boolean asleep;...   while(!asleep)        countSomeSheep();

1 private static ThreadLocal<Connection> connectionHolder2      = new ThreadLocal<Connection>(){3           public Connection initialValue(){4                 return DriverManager.getConnection(DB_URL);5          }6      };7 public static Connection getConnection(){8       return connectionHolder.get();9 }

将JDBC的连接保存到ThreadLocal对象中,调用get方法使得每个线程都拥有属于自己的连接副本。

可以将ThreadLocal<T>看做Map<Thread,T>对象。这些特定于线程的值保存在Thread对象中，当线程终止后，这些值会作为垃圾回收。

@Immutablepublic final class ThreeStooges{    private final Set<String> stooges = new HashSet<String>();    public ThreeStooges(){         stooges.add("Moe");         stooges.add("Larry");         stooges.add("Ted");    }    public boolean isStooge(String name){          return stooges.contains(name);    }}

不可变性并不等于将对象所有的域都声明为final类型，即使对象中所有的域都是final类型，这个对象仍然也可以是可变的，因为在final域中可以保持对可变对象的引用。

对象创建出来后（通过构造方法）无论如何对此对象进行非暴力操作（不用反射），此对象的状态（成员变量的值）都不会发生变化，那么此对象就是不可变的，相应类就是不可变类，跟是否用 final 修饰没关系，final 修饰类是防止此类被继承。

final域

final域不能修改的（尽管如果final域指向的对象是不可变的，这个对象仍然可被修改），然而它在Java内存模式中还有着特殊语义。final域使得确保被始化安全性成为可能，初始化安全性让不可变性对象不需要同步就能自由地被访问和共享。

正如“将所有的域声明为私有的，除非它们需要更高的可见性”一样“将所有的域声明为final型，除非它们是可变的”，也是一条良好的实践。

示例：使用volatile发布不可变的对象

下面是一个不可变对象，进（构造时传进的参数）出（使用时）都对状态进行了拷贝。因为BigInteger是不可变的，所以直接使用了Arrays.copyOf来进行拷贝了，如果状态所指引的对象不是不可变对象时，就不能使用这项技术了，因为外界可以对这些状态所指引的对象进行修改，如果这样只能使用new或深度克隆技术来进行拷贝了。

@Immutableclass 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);    }}

下面开始发布上面不可变对象，其中volatile起关键作用，如果没有它，即使OneValueCache是不可变类，其最新的状态也无法被其他线程可见。

@ThreadSafepublic class VolatileCachedFactorizer implements Servlet {    private volatile OneValueCache cache =        new OneValueCache(null, null);//这里是安全发布     public void service(ServletRequest req, ServletResponse resp) {        BigInteger i = extractFromRequest(req);        BigInteger[] factors = cache.getFactors(i);        if (factors == null) {            factors = factor(i);            //由于cache为volatile，所以最新值立即能让其它线程可见            cache = new OneValueCache(i, factors);        }        encodeIntoResponse(resp, factors);    }}

不可变对象与初始化安全

Java内存模型为共享不可变对象提供了特殊的初始化安全性的保证，即对象在完全初始化之后才能被外界引用。

即使发布对象引用进没有使用同步，不可变对象仍然可以被安全地访问。为了获得这种初始化安全性的保证上，应该满足所有不可变性的条件：不可修改的状态、所有域都是final类型的以及正确的构造。

不可变对象呆以在没有额外同步的情况下，安全地用于任意线程；甚至发布它们时亦不需要同步。

可变对象与安全发布

如果一个对象不是不可变的，它就必须要被安全的发布，通常发布线程与消费线程都必须同步化。我们要确保消费线程能够看到处于发布当时的对象状态。

为了安全地发布对象，对象的引用以及对象的状态必须同时对其他线程可见。一个正确创建的对象可以通过下列条件安全地发布：

1、  通过静态初始化器初始化对象引用；

2、  将它的引用存储到volatile域或AtomicReference;

3、  将它的引用存储到正确创建的对象的Final域中；

4、  或者将它的引用存储到由锁正确保护的域中。

线程安全中的容器提供了线程安全保证，正是遵守了上述最后一条要求。

通常，以最简单和最安全的方式发布一个被静态创建的对象，就是使用静态初始化器：

public static Holder holder = new Holder(42);
静态初始化器由JVM在类的初始阶段执行，由于JVM内在的同步，该机制确保了以这种方式初始化的对象可以被安全地发布。

对象可变性与安全发布

发布对象的必要条件依赖于对象的可变性：

1、  不可变对象可以通过任意机制发布；

2、  高效不可变对象（指对象本身是可变的，但只要发布后状态不再做修改）必须要安全发布；

3、  可变对象必须要安全发布，同时必须要线程安全或者是被锁保护；