Java 并发与多线程规范(3)happen before和volatile总结,ArrayList和CopyOnyWriteList的区别

关于happen before

happen-before是JAVA内存模型中定义的两项操作之间的偏序关系，如果操作A先行发生于操作B,则发生操作B之前,操作A产生的影响都能被操作B观察到。这个原则是判断线程是否安全的重要依据。
下面是几条happen-before规则
1.在一个单独的线程,按照程序代码的执行顺序，先执行的操作happen-before后执行的操作。
2.锁:一个unlock操作happen-before后面对同一个锁的lock操作。
3**volatile:对于一个变量的的写操作happen-before后面对该变量的读操作**。

volatile的语义

volatile 的语义是memory barrier
volatile保持线程之间的可见性，但是i++操作不具备原子性。
可以参考一下Java 内存模型。线程在启动后，读取内存Heap 值复制到自己的工作缓存，比如寄存器、N级缓存等。寄存器、N级缓存在CPU，如果需要其他线程感知的话，需要同步是主存中，如果其他线程看到变量是volatile的话，回去主存加载。

Heap 就存放在主存中，也就是内存中。volatile 实际上是强制线程去主存中读取Heap的信息。所以保证了可见性，无法保证原子性和顺序性。
例子：double-checking-lock

public class SingleTon {
    private static volatile SingleTon instance = null;
    private SingleTon(){}
    public static SingleTon getInstance(){
        if(instance == null){
            synchronized (SingleTon.class) {
                if(instance == null){
                    instance = new SingleTon();
                }
            }
        }
        return instance;
    }
}

如果去掉volatile可能会没有初始化
①分配对象内存
②初始化对象
③设置instance指向刚产生的实例的内存地址
如果没有volatile②③可能发生重排序

ArrayList和CopyOnyWriteList的区别之volatile

我们看一下ArrayList和CopyOnyWriteList的区别

ArrayList

    transient Object[] elementData; // non-private to simplify nested class access

     public E get(int index) {
        rangeCheck(index);
        return elementData(index);
    }

    public boolean add(E e) {
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e;
        return true;
    }

ConpyOnWriteList

    /** The array, accessed only via getArray/setArray. */
    private transient volatile Object[] array;

    public E get(int index) {
        return get(getArray(), index);
    }

public boolean add(E e) {
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            Object[] elements = getArray();
            int len = elements.length;
            Object[] newElements = Arrays.copyOf(elements, len + 1);
            newElements[len] = e;
            setArray(newElements);
            return true;
        } finally {
            lock.unlock();
        }
    }

使用了transient后如何序列化一个ArrayList?

先写入列表大小再挨个写入序列化的元素, API中代码如下：

  private void writeObject(java.io.ObjectOutputStream s)
        throws java.io.IOException{
        // Write out element count, and any hidden stuff
        int expectedModCount = modCount;
        s.defaultWriteObject();
        // Write out size as capacity for behavioural compatibility with clone()
        s.writeInt(size);
        // Write out all elements in the proper order.
        for (int i=0; i<size; i++) {
            s.writeObject(elementData[i]);
        }
        if (modCount != expectedModCount) {
            throw new ConcurrentModificationException();
        }
    }

CopyOnWriteArray数组使用了volatile

保持了线程之间的可见性，然而volatile 仅作用域变量，如果是数组的话，需要再次操作。
我们看到 CopyOnWriteArray的Add方法是复制并扩容一个数组,赋值后令原数组的引用指向新数组。