Examples of java.util.concurrent.atomic.AtomicLongArray

java.util.concurrent.atomic.AtomicLongArray
A {@code long} array in which elements may be updated atomically.See the {@link java.util.concurrent.atomic} package specificationfor description of the properties of atomic variables. @since 1.5 @author Doug Lea

        String text = JSON.toJSONString(array);
        Assert.assertEquals("[1,2,3]", text);
    }


    public void test_AtomicLongArray() throws Exception {
        AtomicLongArray array = new AtomicLongArray(3);
        array.set(0, 1);
        array.set(1, 2);
        array.set(2, 3);
        String text = JSON.toJSONString(array);
        Assert.assertEquals("[1,2,3]", text);
    }

View Full Code Here

    }


    private ByteArrayOrdinalMap(long keys[], ByteDataBuffer byteData, FreeOrdinalTracker freeOrdinalTracker, int keyArraySize) {
        this.freeOrdinalTracker = freeOrdinalTracker;
        this.byteData = byteData;
        AtomicLongArray pointersAndOrdinals = emptyKeyArray(keyArraySize);
        populateNewHashArray(pointersAndOrdinals, keys);
        this.pointersAndOrdinals = pointersAndOrdinals;
        this.size = keys.length;
        this.sizeBeforeGrow = keyArraySize * 7 / 10; /// 70% load factor

View Full Code Here


    /**
     * Grow the key array.  All of the values in the current array must be re-hashed and added to the new array.
     */
    private void growKeyArray() {
        AtomicLongArray newKeys = emptyKeyArray(pointersAndOrdinals.length() * 2);


        long valuesToAdd[] = new long[size];


        int counter = 0;


        /// do not iterate over these values in the same order in which they appear in the hashed array.
        /// if we do so, we cause large clusters of collisions to appear (because we resolve collisions with linear probing).
        for(int i=0;i<pointersAndOrdinals.length();i++) {
            long key = pointersAndOrdinals.get(i);
            if(key != EMPTY_BUCKET_VALUE) {
                valuesToAdd[counter++] = key;
            }
        }


        Arrays.sort(valuesToAdd);


        populateNewHashArray(newKeys, valuesToAdd);


        /// 70% load factor
        sizeBeforeGrow = (newKeys.length() * 7) / 10;
        pointersAndOrdinals = newKeys;
    }

View Full Code Here


    /**
     * Create an AtomicLongArray of the specified size, each value in the array will be EMPTY_BUCKET_VALUE
     */
    private AtomicLongArray emptyKeyArray(int size) {
        AtomicLongArray arr = new AtomicLongArray(size);
        for(int i=0;i<arr.length();i++) {
            arr.set(i, EMPTY_BUCKET_VALUE);
        }
        return arr;
    }

View Full Code Here

    public void set(int position) {
        int segmentPosition = position >>> log2SegmentSize; /// which segment -- div by num bits per segment
        int longPosition = (position >>> 6) & segmentMask; /// which long in the segment -- remainder of div by num bits per segment
        int bitPosition = position & 0x3F; /// which bit in the long -- remainder of div by num bits in long (64)


        AtomicLongArray segment = getSegment(segmentPosition);


        long mask = 1L << bitPosition;


        // Thread safety: we need to loop until we win the race to set the long value.
        while(true) {
            // determine what the new long value will be after we set the appropriate bit.
            long currentLongValue = segment.get(longPosition);
            long newLongValue = currentLongValue | mask;


            // if no other thread has modified the value since we read it, we won the race and we are done.
            if(segment.compareAndSet(longPosition, currentLongValue, newLongValue))
                break;
        }
    }

View Full Code Here

    public boolean get(int position) {
        int segmentPosition = position >>> log2SegmentSize; /// which segment -- div by num bits per segment
        int longPosition = (position >>> 6) & segmentMask; /// which long in the segment -- remainder of div by num bits per segment
        int bitPosition = position & 0x3F; /// which bit in the long -- remainder of div by num bits in long (64)


        AtomicLongArray segment = getSegment(segmentPosition);


        long mask = 1L << bitPosition;


        return ((segment.get(longPosition) & mask) != 0);
    }

View Full Code Here

        ThreadSafeBitSetSegments segments = this.segments.get();


        int numSetBits = 0;


        for(int i=0;i<segments.numSegments();i++) {
            AtomicLongArray segment = segments.getSegment(i);
            for(int j=0;j<segment.length();j++) {
                numSetBits += Long.bitCount(segment.get(j));
            }
        }


        return numSetBits;
    }

View Full Code Here

     */
    public void clearAll() {
        ThreadSafeBitSetSegments segments = this.segments.get();


        for(int i=0;i<segments.numSegments();i++) {
            AtomicLongArray segment = segments.getSegment(i);


            for(int j=0;j<segment.length();j++) {
                segment.set(j, 0L);
            }
        }
    }

View Full Code Here

        ThreadSafeBitSetSegments thisSegments = this.segments.get();
        ThreadSafeBitSetSegments otherSegments = other.segments.get();
        ThreadSafeBitSetSegments newSegments = new ThreadSafeBitSetSegments(thisSegments.numSegments(), numLongsPerSegment);


        for(int i=0;i<thisSegments.numSegments();i++) {
            AtomicLongArray thisArray = thisSegments.getSegment(i);
            AtomicLongArray otherArray = (i < otherSegments.numSegments()) ? otherSegments.getSegment(i) : null;
            AtomicLongArray newArray = newSegments.getSegment(i);


            for(int j=0;j<thisArray.length();j++) {
                long thisLong = thisArray.get(j);
                long otherLong = (otherArray == null) ? 0 : otherArray.get(j);


                newArray.set(j, thisLong & ~otherLong);
            }
        }


        ThreadSafeBitSet andNot = new ThreadSafeBitSet(log2SegmentSize);
        andNot.segments.set(newSegments);

View Full Code Here

                maxNumSegments = segments[i].numSegments();
        }


        ThreadSafeBitSetSegments newSegments = new ThreadSafeBitSetSegments(maxNumSegments, numLongsPerSegment);


        AtomicLongArray segment[] = new AtomicLongArray[segments.length];


        for(int i=0;i<maxNumSegments;i++) {
            for(int j=0;j<segments.length;j++) {
                segment[j] = i < segments[j].numSegments() ? segments[j].getSegment(i) : null;
            }


            AtomicLongArray newSegment = newSegments.getSegment(i);


            for(int j=0;j<numLongsPerSegment;j++) {
                long value = 0;
                for(int k=0;k<segments.length;k++) {
                    if(segment[k] != null)
                        value |= segment[k].get(j);
                }
                newSegment.set(j, value);
            }
        }


        ThreadSafeBitSet or = new ThreadSafeBitSet(log2SegmentSize);
        or.segments.set(newSegments);

View Full Code Here

0 1 2 3 4 5 6 7 8 9

TOP

Related Classes of java.util.concurrent.atomic.AtomicLongArray

com.alibaba.druid.util.Histogram

com.alibaba.fastjson.parser.deserializer.ArrayDeserializer

com.alibaba.fastjson.parser.deserializer.AtomicLongArrayDeserializer

com.alibaba.fastjson.serializer.AtomicLongArrayCodec

com.alibaba.fastjson.serializer.AtomicLongArraySerializer

com.alibaba.json.bvt.bug.Bug_7

com.bah.lucene.blockcache.BlockLocks

com.codahale.metrics.SlidingWindowReservoir

com.codahale.metrics.UniformReservoir

com.datastax.driver.core.StreamIdGenerator

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.