【再读Java并发编程】对象的共享

并发的两层作用：
1 多线程互斥访问；
2 内存可见性；
示例一：没有并发保护的可见性问题。

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

*JMM 重排序
*在没有同步的情况下，编译器、处理器以及运行时等都可能对操作的执行顺序进行意想不到的调整。
失效数据：示例一演示了一种缺乏同步情况下程序产生错误的结果的一种场景。失效数据可能会导致诸如意料之外的异常、被破坏的数据结构、不精确的计算以及无线循环等严重后果。
非原子的64位操作：非volatile的64位double和long变量。JVM允许将64位的读和写操作分解为两个32位的操作。因此，当读取一个非volatile类型的long变量时，如果对该变量的读和写在不同线程中执行，那么很可能会读到某个值的高32位和另一个值的低32位。因此，即使不考虑失效数据问题，在多线程程序中使用共享且可变的long和double等类型的变量也是不安全的，除非用volatile修饰或者用锁保护。
*加锁的含义不仅仅局限于互斥行为，还包括内存可见性。为了确保所有线程都能看到共享变量的最新值，所有执行读操作或者写操作的线程都必须在同一个锁上同步。
*volatile仅能保证内存可见性，无法实现互斥访问。不应过度使用，一般适用于一个线程写，多个线程读的场景。

发布和逸出
发布：使对象能够在当前作用域之外的代码中使用。当发布一个对象时，在该对象的非私有域中引用的所有对象同样会被发布。一般来说，如果一个已经发布的对象能够通过非私有的变量引用和方法调用到达其他对象，那么这些对象也都会被发布。
逸出：某个不应该发布的对象被发布。例如，在对象构造完成之前就发布该对象，会破坏线程安全性
封装：能够使得对程序的正确性进行分析变得可能，并使得无意中破坏设计约束条件变得更难。
示例二：发布一个内部类实例，同样会导致一个对象或其内部状态被发布，因为内部类实例包含了对外部类实例的隐含引用：

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

安全的对象构造
当从对象的构造函数中发布对象时，只是发布了一个尚未构造完成的对象。即使发布对象的语句位于构造函数的最后一行也是如此。
*不要在构造函数中使this引用逸出。

1. 如果在构造函数中创建线程，但最好不要直接启动它，而是通过一个start或initialize方法来启动；
2. 如果在构造函数中调用一个可改写的实例方法(非私有，非final)，也会导致this引用在构造过程中逸出。
   示例三：使用私有构造函数加公有的工厂方法防止this引用在构造过程中逸出：

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

线程封闭
当某个对象封闭在一个线程中时，这种用法将自动实现线程安全性，即使被封闭的对象本身不是线程安全的。
两个应用框架：Swing 和 JDBC。

1. Ad-hoc线程封闭：维护线程封闭的职责完全由程序实现来承担。比较脆弱，尽量少用；

2. 栈封闭：只能通过局部变量才能访问对象。比Ad-hoc线程封闭更易于维护，也更健壮。需要避免被封闭的对象逸出。
   示例三：栈封闭。通过基本类型的局部变量与引用变量的线程封闭性，将animals对象封闭在线程内部。

    public int loadTheArk(Collection<Animal> candidates)
    {
        SortedSet<Animal> animals;
        int numPairs = 0;
        Animal candidate  = null;
    
        // animals被封闭在方法中，不要使它们逸出
        animals = new TreeSet<Animal>(new SpeciesGenderComparator());
        animals.addAll(candidate);
        for(Animal a: animals)
        {
           if(null == candidate || !candidate.isPotentialMate(a))
           {
             candidate = a;
           }
           else
           {
             ark.load(new AnimalPair(candidate, a));
             ++numPairs;
             candidate = null;
           }
        }
        return numPairs;
    }
   

   3. ThreadLocal类：ThreadLocal提供了get、set等访问接口或方法，这些方法为每个使用该变量的线程都存有一份独立的副本，因此使用get总是返回由当前执行线程在调用set时设置的最新值。
      通常用于防止对可变的单实例变量或全局变量进行共享。避免滥用。
      示例四：使用ThreadLocal来维持线程封闭性：

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

    public static Connection getConnection()
    {
        return connectionHolder.get();
    }

不变性
不可变对象一定是线程安全的，满足以下条件时，对象才是不可变的：
1 对象创建以后其状态就不能修改；
2 对象的所有域都是final类型；
3 对象时正确创建地，在对象创建期间，this引用没有逸出。

Final域
Final域能确保初始化过程中的安全性，从而可以不受限制的访问不可变对象，并在共享这些对象时无需同步。
*除非需要更高的可见性，否则应将所有的域都声明为私有域；除非某个域是可变的，否则应将其生命为Final域。

安全发布的常用模式
要安全的发布一个对象，对象的引用以及对象的状态必须同时对其他线程可见。一个正确构造的对象可以通过以下方式来安全的发布：
1 在静态初始化函数中初始化一个对象引用；
public static Holder holder = new Holder();//静态初始化器由JVM在类的初始化阶段执行，JVM内部存在同步机制，因此通过这种方式初始化的任何对象都可以安全的发布。
2 将对象的引用保存到volatile类型的域或者AtomicReference对象中；
3 将对象的引用保存到某个正确构造对象的final类型域中；
4 将对象的引用保存到一个由锁保护的域中。

线程安全库中的容器类提供了以下的安全发布保证：
1 通过将一个键或者值放入Hashtable、synchronizedMap或者ConcurrentMap中，可以安全的将它发布给任何从这些容器中访问它的线程(无论是直接访问还是通过迭代器访问)。
2 通过将某个元素放入Vector、CopyOnWriteArrayList、CopyOnWriteArraySet、synchronizedList或synchronizedSet中，可以将该元素安全的发布到任何从这些容器中访问该元素的线程；
3 通过将某个元素放入BlockingQueue或ConcurrentLinkedQueue中，可以将该元素安全的发布到任何从这些队列中访问该元素的线程。