Java AtomicIntegerArray类代码示例

import java.util.concurrent.atomic.AtomicIntegerArray; //导入依赖的package包/类
public void write(JSONSerializer serializer, Object object, Object fieldName, Type fieldType) throws IOException {
    SerializeWriter out = serializer.getWriter();
    if (object != null) {
        AtomicIntegerArray array = (AtomicIntegerArray) object;
        int len = array.length();
        out.append('[');
        for (int i = 0; i < len; i++) {
            int val = array.get(i);
            if (i != 0) {
                out.write(',');
            }
            out.writeInt(val);
        }
        out.append(']');
    } else if (out.isEnabled(SerializerFeature.WriteNullListAsEmpty)) {
        out.write("[]");
    } else {
        out.writeNull();
    }
}
 

import java.util.concurrent.atomic.AtomicIntegerArray; //导入依赖的package包/类
public PartitionSenderOperator(
    OperatorContext context,
    TunnelProvider tunnelProvider,
    HashPartitionSender config) {
  super(config);
  this.context = context;
  this.tunnelProvider = tunnelProvider;
  this.config = config;
  this.stats = context.getStats();
  outGoingBatchCount = config.getDestinations().size();
  remainingReceivers = new AtomicIntegerArray(outGoingBatchCount);
  remaingReceiverCount = new AtomicInteger(outGoingBatchCount);
  stats.setLongStat(Metric.N_RECEIVERS, outGoingBatchCount);
  // Algorithm to figure out number of threads to parallelize output
  // numberOfRows/sliceTarget/numReceivers/threadfactor
  this.cost = config.getChild().getCost();
  this.numberPartitions = getNumberPartitions(context, config);
  this.actualPartitions = outGoingBatchCount > numberPartitions ? numberPartitions : outGoingBatchCount;
  this.stats.setLongStat(Metric.SENDING_THREADS_COUNT, actualPartitions);
  this.stats.setDoubleStat(Metric.COST, this.cost);
  logger.debug("Preliminary number of sending threads is: " + numberPartitions);
}
 

import java.util.concurrent.atomic.AtomicIntegerArray; //导入依赖的package包/类
public void test_AtomicIntegerArray() throws Exception {
    AtomicIntegerArray array = new AtomicIntegerArray(3);
    array.set(0, 1);
    array.set(1, 2);
    array.set(2, 3);
    String text = JSON.toJSONString(array);
    Assert.assertEquals("[1,2,3]", text);
}
 

import java.util.concurrent.atomic.AtomicIntegerArray; //导入依赖的package包/类
private AtomicIntegerArray getArray(int index) {
	int arrayIndex = arrayIndex(index);
	if (size <= index) {
		synchronized(arrays) {
			if (size <= index) {
				size = index + 1;
			}
		}
	}
	if (arrayIndex < arrays.size()) return arrays.get(arrayIndex);
	synchronized(arrays) {
		while (arrays.size() <= arrayIndex) arrays.add(new AtomicIntegerArray(capacityStep));			
	}
	return arrays.get(arrayIndex);
}
 

import java.util.concurrent.atomic.AtomicIntegerArray; //导入依赖的package包/类
public Accuracy(int[] bins) {
    this.bins = bins;
    pos = new AtomicIntegerArray(bins.length);
    posCorrect = new AtomicIntegerArray(bins.length);
    neg = new AtomicIntegerArray(bins.length);
    negCorrect = new AtomicIntegerArray(bins.length);
}
 

import java.util.concurrent.atomic.AtomicIntegerArray; //导入依赖的package包/类
/**
 * constructor with null array throws NPE
 */
public void testConstructor2NPE() {
    try {
        int[] a = null;
        new AtomicIntegerArray(a);
        shouldThrow();
    } catch (NullPointerException success) {}
}
 

import java.util.concurrent.atomic.AtomicIntegerArray; //导入依赖的package包/类
/**
 * compareAndSet succeeds in changing value if equal to expected else fails
 */
public void testCompareAndSet() {
    AtomicIntegerArray aa = new AtomicIntegerArray(SIZE);
    for (int i = 0; i < SIZE; i++) {
        aa.set(i, 1);
        assertTrue(aa.compareAndSet(i, 1, 2));
        assertTrue(aa.compareAndSet(i, 2, -4));
        assertEquals(-4, aa.get(i));
        assertFalse(aa.compareAndSet(i, -5, 7));
        assertEquals(-4, aa.get(i));
        assertTrue(aa.compareAndSet(i, -4, 7));
        assertEquals(7, aa.get(i));
    }
}
 

import java.util.concurrent.atomic.AtomicIntegerArray; //导入依赖的package包/类
/**
 * get returns the last value setRelease
 */
public void testGetSetRelease() {
    AtomicIntegerArray aa = new AtomicIntegerArray(SIZE);
    for (int i = 0; i < SIZE; i++) {
        aa.setRelease(i, 1);
        assertEquals(1, aa.get(i));
        aa.setRelease(i, 2);
        assertEquals(2, aa.get(i));
        aa.setRelease(i, -3);
        assertEquals(-3, aa.get(i));
    }
}
 

import java.util.concurrent.atomic.AtomicIntegerArray; //导入依赖的package包/类
static void test_2ci_oppos(AtomicIntegerArray a, AtomicIntegerArray b) {
  int limit = ARRLEN-1;
  for (int i = 0; i < ARRLEN; i+=1) {
    a.set((limit-i), -123);
    b.set(i, -103);
  }
}
 

import java.util.concurrent.atomic.AtomicIntegerArray; //导入依赖的package包/类
static void test_2vi_oppos(AtomicIntegerArray a, AtomicIntegerArray b, int c, int d) {
  int limit = ARRLEN-1;
  for (int i = limit; i >= 0; i-=1) {
    a.set(i, c);
    b.set((limit-i), d);
  }
}
 

import java.util.concurrent.atomic.AtomicIntegerArray; //导入依赖的package包/类
/**
 * repeated weakCompareAndSetAcquire succeeds in changing value when equal
 * to expected
 */
public void testWeakCompareAndSetAcquire() {
    AtomicIntegerArray aa = new AtomicIntegerArray(SIZE);
    for (int i = 0; i < SIZE; i++) {
        aa.set(i, 1);
        do {} while (!aa.weakCompareAndSetAcquire(i, 1, 2));
        do {} while (!aa.weakCompareAndSetAcquire(i, 2, -4));
        assertEquals(-4, aa.get(i));
        do {} while (!aa.weakCompareAndSetAcquire(i, -4, 7));
        assertEquals(7, aa.get(i));
    }
}
 

import java.util.concurrent.atomic.AtomicIntegerArray; //导入依赖的package包/类
/**
 * getAndSet returns previous value and sets to given value at given index
 */
public void testGetAndSet() {
    AtomicIntegerArray aa = new AtomicIntegerArray(SIZE);
    for (int i = 0; i < SIZE; i++) {
        aa.set(i, 1);
        assertEquals(1, aa.getAndSet(i, 0));
        assertEquals(0, aa.getAndSet(i, -10));
        assertEquals(-10, aa.getAndSet(i, 1));
    }
}
 

import java.util.concurrent.atomic.AtomicIntegerArray; //导入依赖的package包/类
/**
 * get returns the last value set at index
 */
public void testGetSet() {
    AtomicIntegerArray aa = new AtomicIntegerArray(SIZE);
    for (int i = 0; i < SIZE; i++) {
        aa.set(i, 1);
        assertEquals(1, aa.get(i));
        aa.set(i, 2);
        assertEquals(2, aa.get(i));
        aa.set(i, -3);
        assertEquals(-3, aa.get(i));
    }
}
 

import java.util.concurrent.atomic.AtomicIntegerArray; //导入依赖的package包/类
/**
 * AtomicIntegerArray updateAndGet updates with supplied function and
 * returns result.
 */
public void testIntArrayUpdateAndGet() {
    AtomicIntegerArray a = new AtomicIntegerArray(1);
    a.set(0, 1);
    assertEquals(18, a.updateAndGet(0, Atomic8Test::addInt17));
    assertEquals(35, a.updateAndGet(0, Atomic8Test::addInt17));
    assertEquals(35, a.get(0));
}
 

import java.util.concurrent.atomic.AtomicIntegerArray; //导入依赖的package包/类
/**
 * All Atomic getAndUpdate methods throw NullPointerException on
 * null function argument
 */
public void testGetAndUpdateNPE() {
    Runnable[] throwingActions = {
        () -> new AtomicLong().getAndUpdate(null),
        () -> new AtomicInteger().getAndUpdate(null),
        () -> new AtomicReference().getAndUpdate(null),
        () -> new AtomicLongArray(1).getAndUpdate(0, null),
        () -> new AtomicIntegerArray(1).getAndUpdate(0, null),
        () -> new AtomicReferenceArray(1).getAndUpdate(0, null),
        () -> aLongFieldUpdater().getAndUpdate(this, null),
        () -> anIntFieldUpdater().getAndUpdate(this, null),
        () -> anIntegerFieldUpdater().getAndUpdate(this, null),
    };
    assertThrows(NullPointerException.class, throwingActions);
}