Java高并发程序-Chapter5 锁的优化及注意事项（第三十四讲）无锁 - LockFreeVector

LockFreeVector： 无锁Vector

1. Descriptor

static class Descriptor<E> {  
    public int size;  
    volatile WriteDescriptor<E> writeop;  
    public Descriptor(int size, WriteDescriptor<E> writeop) {  
        this.size = size;  
        this.writeop = writeop;  
    }  
    public void completeWrite() {  
        WriteDescriptor<E> tmpOp = writeop;  
        if (tmpOp != null) {  
            tmpOp.doIt();  
            writeop = null; // this is safe since all write to writeop use  
            // null as r_value.  
        }  
    }  
}  
  
static class WriteDescriptor<E> {  
    public E oldV;  
    public E newV;  
    public AtomicReferenceArray<E> addr;  
    public int addr_ind;  
  
    public WriteDescriptor(AtomicReferenceArray<E> addr, int addr_ind,  
            E oldV, E newV) {  
        this.addr = addr;  
        this.addr_ind = addr_ind;  
        this.oldV = oldV;  
        this.newV = newV;  
    }  
  
    public void doIt() {  
        addr.compareAndSet(addr_ind, oldV, newV);  
    }  
} 

2. 构造器

public LockFreeVector() {    
    buckets = new AtomicReferenceArray<AtomicReferenceArray<E>>(N_BUCKET);    
    buckets.set(0, new AtomicReferenceArray<E>(FIRST_BUCKET_SIZE));    
    descriptor = new AtomicReference<Descriptor<E>>(new Descriptor<E>(0,    
            null));    
}   

变量buckets存放所有的内部元素。从定义上看，它是一个保存着数组的数组，也就是通常的二维数组。特别之处在于这些数组都是使用CAS的原子数组。为什么使用二维数组去实现一个一维的Vector呢？这是为了将来Vector进行动态扩展时可以更加方便。我们知道，AtomicReferenceArray内部使用Object[]来进行实际数据的存储，这使得动态空间增加特别的麻烦，因此使用二维数组的好处就是为将来增加新的元素。

N_BUCKET：30
在这里N_BUCKET为30,也就是说这个buckets里面可以存放一共30个数组（由于数组无法动态增长，因此数组总数也就不能超过30个）。并且将第一个数组的大小为FIRST_BUCKET_SIZE为8。到这里，大家可能会有一个疑问，如果每个数组8个元素，一共30个数组，那岂不是一共只能存放240个元素吗？
    如果大家了解JDK内的Vector实现，应该知道，Vector在进行空间增长时，默认情况下，每次都会将总容量翻倍。因此，这里也借鉴类似的思想，每次空间扩张，新的数组的大小为原来的2倍（即每次空间扩展都启用一个新的数组），因此，第一个数组为8，第2个就是16，第3个就是32。以此类推，因此30个数组可以支持的总元素达到。

这数值已经超过了2^33，即在80亿以上。因此，可以满足一般的应用

3. push_back

在第23行，使用descriptor将数据真正地写入数组中。这个descriptor写入的数据由20~21行构造的WriteDescriptor决定。

在循环最开始（第5行），使用descriptor先将数据写入数组，是为了防止上一个线程设置完descriptor后（22行），还没来得及执行第23行的写入，因此，做一次预防性的操作。

第8~10行通过当前Vector的大小（desc.size），计算新的元素应该落入哪个数组。这里使用了位运算进行计算。

LockFreeVector每次都会扩容。它的第一个数组长度为8，第2个就是16，第3个就是32，依次类推。它们的二进制表示如下：

它们之和就是整个LockFreeVector的总大小，因此，如果每一个数组都恰好填满，那么总大小应该类似如下的值（以4个数组为例）00000000 00000000 00000000 01111000：4个数组都恰好填满时的大小。

导致这个数字进位的最小条件，就是加上二进制的1000。而这个数字整好是8（FIRST_BUCKET_SIZE就是8）这就是第8行代码的意义。

它可以使得数组大小发生一次二进制进位（如果不进位说明还在第一个数组中），进位后前导零的数量就会发生变化。而元素所在的数组，和pos（第8行定义的比变量）的前导零直接相关。每进行一次数组扩容，它的前导零就会减1。如果从来没有扩容过，它的前导零就是28个。以后，逐级减1。这就是第9行获得pos前导零的原因。第10行，通过pos的前导零可以立即定位使用哪个数组（也就是得到了bucketInd的值）。

第11行，判断这个数组是否存在。如果不存在，则创建这个数组，大小为前一个数组的两倍，并把它设置到buckets中。

接着再看一下元素没有恰好填满的情况：



那么总大小如下：


总个数加上二进制1000后，得到：

显然，通过前导零可以定位到第4个数组。而剩余位，显然就表示元素在当前数组内偏移量（也就是数组下标）。根据这个理论，就可以通过pos计算这个元素应该放在给定数组的哪个位置。通过第19行代码，获得pos的除了第一位数字1以外的其他位的数值。因此，pos的前导零可以表示元素所在的数组，而pos的后面几位，则表示元素所在这个数组中的位置。由此，第19行代码就取得了元素所在位置idx。