四川盐亭网站制作公司

Java高并发四：无锁的实际应用

无 锁 算法 详 解
无 锁 的Vector 实现：
参照着JDK中的 Vector 源码
1、Vector中的 add 方法的实现，它是一个同步方法，所以保证了每一次只能又一个值对数组 elementData 进行操作。
protected Object[] elementData; 通过数据来实现存储
protected int elementCount; 记录对这个Vector的操作数

成都服务器托管，创新互联建站提供包括服务器租用、西云机房、带宽租用、云主机、机柜租用、主机租用托管、CDN网站加速、域名申请等业务的一体化完整服务。电话咨询：028-86922220

public synchronized boolean add(E e) {
modCount++;
ensureCapacityHelper(elementCount + 1);//这边是做越界判断
elementData[elementCount++] = e;
return true;
}

private void ensureCapacityHelper(int minCapacity) {
// overflow-conscious code
if (minCapacity - elementData.length > 0)
grow(minCapacity);//如果没有越界
}

private void grow(int minCapacity) {
// overflow-conscious code
int oldCapacity = elementData.length;
int newCapacity = oldCapacity + ((capacityIncrement > 0) ?
capacityIncrement : oldCapacity);
//如果初始化的时候不指定增量capacityIncrement，那么就是将oldCapacity+oldCapacity赋值给新的长度，如果指定增量那么就是oldCapacity+capacityIncrement
if (newCapacity - minCapacity < 0)
newCapacity = minCapacity;
if (newCapacity - MAX_ARRAY_SIZE > 0)
newCapacity = hugeCapacity(minCapacity);
elementData = Arrays.copyOf(elementData, newCapacity);
//最后将老的元素和新的一起加入到Vector中
}
public static T[] copyOf(T[] original, int newLength) {
return (T[]) copyOf(original, newLength, original.getClass());
}
值得注意的一点就是如果指定增量，那么可以减少空间的浪费。

JDK阅读只是为未无锁的Vector做铺垫

无锁的Vector的实现

/**

  • @author Allen李

  • @date
    /
    public class LockFreeVector extends AbstractList{
    private static final boolean debug = false;
    private static final int FIRST_BUCKET_SIZE = 8;
    //虽然这边篮子的个数是固定的，但是绝对是够用的因为总共的篮子数就是8    2^30-1
    private static final int N_BUCKET = 30;
    private final AtomicReferenceArray> buckets;
    //利用二维数组来嵌套是为了使一维的AtomicReferenceArray尽量避免修改，在一维数组填充满了时是不会去扩充的，
    // 而是往二维数组里面填充，这样就避免了修改一维数组，而且高并发就是避免不必要的写来影响性能
    public LockFreeVector(AtomicReferenceArray> buckets) {
    this.buckets = buckets;
    }
    static class WriteDescriptor{
    public E oldV;
    public E newV;
    public AtomicReferenceArray addr;
    public int addr_ind;

    public WriteDescriptor( AtomicReferenceArray addr, int addr_ind,E oldV, E newV) {
    this.oldV = oldV;
    this.newV = newV;
    this.addr = addr;
    this.addr_ind = addr_ind;
}

public void doInt(){
    addr.compareAndSet(addr_ind,oldV,newV);
}

    }
    static class Descriptor{
    public int size;
    volatile WriteDescriptor writeOp;

    public Descriptor(int size, WriteDescriptor writeOp) {
    this.size = size;
    this.writeOp = writeOp;
}

public void completeWrite(){
    WriteDescriptor tmpOp = writeOp;
    if(tmpOp != null){
        tmpOp.doInt();
        writeOp=null;
    }
}

    }

    private AtomicReference> descriptor;
    private static final int zeroNumFirst = Integer.numberOfLeadingZeros(FIRST_BUCKET_SIZE);

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

    public void push_back(E e){
    Descriptor desc;
    Descriptor newD;

    do {
    desc=descriptor.get();
    desc.completeWrite();
    int pos = desc.size+FIRST_BUCKET_SIZE;
    int zeroNumPos = Integer.numberOfLeadingZeros(pos);
    int bucketInd = zeroNumFirst - zeroNumPos;
    if(buckets.get(bucketInd)==null){
        int newLen = 2 * buckets.get(bucketInd - 1).length();
        if (debug)
            System.out.println("New Length is:"+newLen);
        buckets.compareAndSet(bucketInd,null,new AtomicReferenceArray(newLen));
    }
    //0x80000000就是1000000...  总共32位
    int idx = (0x80000000>>>zeroNumPos) ^ pos;
    newD = new Descriptor<>(desc.size + 1,new WriteDescriptor(buckets.get(bucketInd),idx,null, e));
}while (!descriptor.compareAndSet(desc,newD));
descriptor.get().completeWrite();

    }

    public E pop_back(){
    Descriptor desc;
    Descriptor newD;
    E elem;
    do {
    desc = descriptor.get();
    desc.completeWrite();
    int pos = desc.size + FIRST_BUCKET_SIZE - 1;
    int bucketInd = Integer.numberOfLeadingZeros(FIRST_BUCKET_SIZE) - Integer.numberOfLeadingZeros(pos);
    int idx = Integer.highestOneBit(pos) ^ pos;
    elem = buckets.get(bucketInd).get(idx);
    newD = new Descriptor(desc.size - 1,null);
    }while (!descriptor.compareAndSet(desc,newD));

    return elem;

    }

    @Override
    public E get(int index){
    int pos = index + FIRST_BUCKET_SIZE;
    int zeroNumPos = Integer.numberOfLeadingZeros(pos);
    int bucketInd = zeroNumFirst - zeroNumPos;
    int idx = (0x80000000>>>zeroNumPos) ^ pos;
    return buckets.get(bucketInd).get(idx);
    }

    @Override
    public E set(int index,E e){
    int pos = index + FIRST_BUCKET_SIZE;
    int bucketInd = Integer.numberOfLeadingZeros(FIRST_BUCKET_SIZE) - Integer.numberOfLeadingZeros(pos);
    int idx = Integer.highestOneBit(pos) ^ pos;
    AtomicReferenceArray bucket = buckets.get(bucketInd);
    while (true){
    E oldV = bucket.get(idx);
    if (bucket.compareAndSet(idx,oldV,e))
    return oldV;
    }
    }

    public void reserve(int newSize){
    int size = descriptor.get().size;
    int pos = size + FIRST_BUCKET_SIZE - 1;
    int i = Integer.numberOfLeadingZeros(FIRST_BUCKET_SIZE) - Integer.numberOfLeadingZeros(pos);

    if (i<1)
    i = 1;

int initialSize = buckets.get(i - 1).length();
while (i < Integer.numberOfLeadingZeros(FIRST_BUCKET_SIZE) - Integer.numberOfLeadingZeros(newSize + FIRST_BUCKET_SIZE - 1)){
    i++;
    initialSize *= FIRST_BUCKET_SIZE;
    buckets.compareAndSet(i, null , new AtomicReferenceArray(initialSize));
}

    }

    public int size(){
    return descriptor.get().size;
    }

    @Override
    public boolean add(E obj){
    push_back(obj);
    return true;
    }
    }
    它的结构是：private final AtomicReferenceArray> buckets;
    从这里我们可以看到，它的内部是采用的是 无锁的引用数组， 数组嵌套数组
    变量buckets存放所有的内部元素。从定义上看，它是一个保存着数组的数组，也就是通常的二维数组。特别之处在于这些数组都是使用CAS的原子数组。为什么使用二维数组去实现一个一维的Vector呢？这是为了将来Vector进行动态扩展时可以更加方便。我们知道，AtomicReferenceArray内部使用Object[]来进行实际数据的存储，这使得动态空间增加特别的麻烦，因此使用二维数组的好处就是为将来增加新的元素。

相当于一个二维数组，它的大小可以动态的进行扩展，

为了更有序的读写数组，定义了一个Descriptor的静态内部类。它的作用是使用CAS操作写入新数据。

它定义了

private static final int FIRST_BUCKET_SIZE = 8;

/**

  • number of buckets. 30 will allow 8(2^30-1) elements
    /
    private static final int N_BUCKET = 30;

FIRST_BUCKET_SIZE：为第一个数组的长度

N_BUCKET 整个二维数组最大可扩转至30

每次的扩展是成倍的增加，即：第一个数组长度为8，第二个为8<<1，第三个为8<<2 ......第30个为 8<<29

3. push_back
Java 高并发四：无锁的实际应用
Java 高并发四：无锁的实际应用

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

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

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

LockFreeVector每次都会扩容。它的第一个数组长度为8，第2个就是16，第3个就是32，依次类推。它们的二进制表示如下：
Java 高并发四：无锁的实际应用

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

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

它可以使得数组大小发生一次二进制进位（如果不进位说明还在第一个数组中），进位后前导零的数量就会发生变化。而元素所在的数组，和pos（第8行定义的比变量）的前导零直接相关。每进行一次数组扩容，它的前导零就会减1。如果从来没有扩容过，它的前导零就是28个。以后，逐级减1。这就是第9行获得pos前导零的原因。第10行，通过pos的前导零可以立即定位使用哪个数组（也就是得到了bucketInd的值）。
Java 高并发四：无锁的实际应用
第11行，判断这个数组是否存在。如果不存在，则创建这个数组，大小为前一个数组的两倍，并把它设置到buckets中。

Java 高并发四：无锁的实际应用

接着再看一下元素没有恰好填满的情况：
Java 高并发四：无锁的实际应用

那么总大小如下：
Java 高并发四：无锁的实际应用

总个数加上二进制1000后，得到：
Java 高并发四：无锁的实际应用

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

代码理解可以参考：
https://blog.csdn.net/netcobol/article/details/79785651
和
http://www.shaoqun.com/a/197387.html


当前标题：Java高并发四：无锁的实际应用
文章出自：http://scyanting.com/article/ijiigp.html

其他资讯