public class NoVisibility {
     private static boolean ready;
     private static int number;
     public static class ReaderThread extends Thread {
         public void run(){
         while(!ready)
            Thread.yield();
         System.out.println(number);
         }
     }
     public static void main(String []args) {
         new ReaderThread( ).start();
         number = 42;
         ready = true;
     }
}

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

• 对变量的写入操作不依赖变量的当前值(如count++)，或者你能确保只有单个线程更新变量的值
• 该变量不会与其他状态变量一起纳入不变性条件中
• 在访问变量时不需要加锁(因为volatile只确保可见性)

     public class ThisEscape {
          public ThisEscape(EventSource source) {
               source.registerListener(
                    new EventListener() {
                         public void onEvent(Event e) {
                              doSomething(e);
                         }
                    } );
     }
} 

     public class SafeListener {
          private final EventListener listner;
          private SafeListener() {
               listner = new EventListener() {
                    public void onEvent(Event e) {
                         doSomething( e );
                    }
               };
          }
          public static SafeListener newInstance( EventSource source ) {
               SafeListener safe = new SafeListener( );
               souce.registerListener( safa.listener );
               return safe;
          }
     }

private static ThreadLocal<Connection> connectionHolder
     = new ThreadLocal<Connnection>( ) {
          public Connection initialValue( ) {
               return DriverManager.getConnection(DB_URL);
          } ;
     public static Connection getConnection( ) {
          return connectionHolder.get( );
     }
}

• 对象是正确创建的(在对象的创建期间，this引用没有逸出)
• 对象创建之后其状态就不能修改
• 对象的所有域都是final类型

@Immutable
class OneValueCache {
    private final BigInteger lastNumber;
    private final BigInteger[] lastFactors;
    public OneValueCache(BigInteger i, BigInteger[] factors) {
        lastNumber = i;
        lastFactors = factors;
    }
    public BigInteger[] getFactors( BigInteger i ) {
         if(lastNumber == null || !lastNumber.equals(i)) {
              return null;
         } else {
              return Arrays.copyOf(lastFactors, lastFactors.length );
         }
    }
}

public 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 = new OneValueCache(i, factors);
        }
        encodeIntoResponse(resp, factors);
    }
}