@Test public void DoubleConsumer() { DoubleAdder adder = new DoubleAdder(); // TODO - Convert the anonymous inner class to a lambda DoubleConsumer consumer = new DoubleConsumer() { @Override public void accept(double value) { adder.add(value); } }; DoubleStream.of(1.0, 2.0, 3.0, 4.0, 5.0).forEach(consumer); Assert.assertEquals(15.0, adder.doubleValue(), 0.0); }
/** * adds by multiple threads produce correct sum */ public void testAddAndSumMT() throws Throwable { final int incs = 1000000; final int nthreads = 4; final ExecutorService pool = Executors.newCachedThreadPool(); DoubleAdder a = new DoubleAdder(); CyclicBarrier barrier = new CyclicBarrier(nthreads + 1); for (int i = 0; i < nthreads; ++i) pool.execute(new AdderTask(a, barrier, incs)); barrier.await(); barrier.await(); double total = (long)nthreads * incs; double sum = a.sum(); assertEquals(sum, total); pool.shutdown(); }
@Override public List<Measurement> measure() { ConcurrentMap<String, DoubleAdder> mapToProcess = counts; counts = new ConcurrentHashMap<>(); if (cloudwatchClient != null && hasCloudwatchConfig != null && hasCloudwatchConfig.auditeventStatisticsEnabled()) { List<CloudwatchClient.CloudwatchStatistic> statistics = mapToProcess.entrySet().stream() .map(e -> new CloudwatchClient.CloudwatchStatistic(e.getKey(), e.getValue().doubleValue())) .collect(toList()); cloudwatchClient.sendStatistics(hasCloudwatchConfig.auditeventStatisticsNamespace(), statistics); } return mapToProcess.entrySet().stream() .map(e -> new Measurement("audit." + e.getKey(), "INFO", "Last minute: " + e.getValue().doubleValue())) .collect(toList()); }
public void write(JSONSerializer serializer, Object object, Object fieldName, Type fieldType, int features) throws IOException { SerializeWriter out = serializer.out; if (object instanceof LongAdder) { out.writeFieldValue('{', "value", ((LongAdder) object).longValue()); out.write('}'); } else if (object instanceof DoubleAdder) { out.writeFieldValue('{', "value", ((DoubleAdder) object).doubleValue()); out.write('}'); } }
public void test_long_add() throws Exception { DoubleAdder adder = new DoubleAdder(); adder.add(3); String json = JSON.toJSONString(adder); assertEquals("{\"value\":3.0}", json); }
static void adderTest(int nthreads, int incs) { System.out.print("DoubleAdder "); Phaser phaser = new Phaser(nthreads + 1); DoubleAdder a = new DoubleAdder(); for (int i = 0; i < nthreads; ++i) pool.execute(new AdderTask(a, phaser, incs)); report(nthreads, incs, timeTasks(phaser), a.sum()); }
public void run() { phaser.arriveAndAwaitAdvance(); phaser.arriveAndAwaitAdvance(); DoubleAdder a = adder; for (int i = 0; i < incs; ++i) a.add(1.0); result = a.sum(); phaser.arrive(); }
static void testDoubleAdder() { DoubleAdder a = new DoubleAdder(); a.add(20.1d); DoubleAdder result = echo(a); if (result.doubleValue() != a.doubleValue()) throw new RuntimeException("Unexpected doubleValue"); checkSerialClassName(a, "java.util.concurrent.atomic.DoubleAdder$SerializationProxy"); }
/** * add adds given value to current, and sum returns current value */ public void testAddAndSum() { DoubleAdder ai = new DoubleAdder(); ai.add(2.0); assertEquals(2.0, ai.sum()); ai.add(-4.0); assertEquals(-2.0, ai.sum()); }
/** * reset() causes subsequent sum() to return zero */ public void testReset() { DoubleAdder ai = new DoubleAdder(); ai.add(2.0); assertEquals(2.0, ai.sum()); ai.reset(); assertEquals(0.0, ai.sum()); }
/** * sumThenReset() returns sum; subsequent sum() returns zero */ public void testSumThenReset() { DoubleAdder ai = new DoubleAdder(); ai.add(2.0); assertEquals(2.0, ai.sum()); assertEquals(2.0, ai.sumThenReset()); assertEquals(0.0, ai.sum()); }
/** * a deserialized/reserialized adder holds same value */ public void testSerialization() throws Exception { DoubleAdder x = new DoubleAdder(); DoubleAdder y = serialClone(x); assertNotSame(x, y); x.add(-22.0); DoubleAdder z = serialClone(x); assertEquals(-22.0, x.sum()); assertEquals(0.0, y.sum()); assertEquals(-22.0, z.sum()); }
/** * toString returns current value. */ public void testToString() { DoubleAdder ai = new DoubleAdder(); assertEquals(Double.toString(0.0), ai.toString()); ai.add(1.0); assertEquals(Double.toString(1.0), ai.toString()); }
/** * intValue returns current value. */ public void testIntValue() { DoubleAdder ai = new DoubleAdder(); assertEquals(0, ai.intValue()); ai.add(1.0); assertEquals(1, ai.intValue()); }
/** * longValue returns current value. */ public void testLongValue() { DoubleAdder ai = new DoubleAdder(); assertEquals(0, ai.longValue()); ai.add(1.0); assertEquals(1, ai.longValue()); }
/** * floatValue returns current value. */ public void testFloatValue() { DoubleAdder ai = new DoubleAdder(); assertEquals(0.0f, ai.floatValue()); ai.add(1.0); assertEquals(1.0f, ai.floatValue()); }
/** * doubleValue returns current value. */ public void testDoubleValue() { DoubleAdder ai = new DoubleAdder(); assertEquals(0.0, ai.doubleValue()); ai.add(1.0); assertEquals(1.0, ai.doubleValue()); }
public void run() { try { barrier.await(); DoubleAdder a = adder; for (int i = 0; i < incs; ++i) a.add(1.0); result = a.sum(); barrier.await(); } catch (Throwable t) { throw new Error(t); } }
/** * a deserialized serialized adder holds same value */ public void testSerialization() throws Exception { DoubleAdder x = new DoubleAdder(); DoubleAdder y = serialClone(x); assertNotSame(x, y); x.add(-22.0); DoubleAdder z = serialClone(x); assertEquals(-22.0, x.sum()); assertEquals(0.0, y.sum()); assertEquals(-22.0, z.sum()); }
public static boolean isTooBigForJs(Number value) { if (value instanceof Double || value instanceof Float || value instanceof DoubleAdder || value instanceof Integer || value instanceof AtomicInteger || value instanceof Short || value instanceof Byte) { return false; } else if (value instanceof BigDecimal) { BigDecimal decimal = (BigDecimal) value; int exp = decimal.precision() - decimal.scale() - 1; return decimal.unscaledValue().compareTo(Holder.MAX_SAFE_MANTISSA) > 0 || exp > Holder.MAX_SAFE_EXPONENT || exp < Holder.MIN_SAFE_EXPONENT; } else if (value instanceof BigInteger) { return ((BigInteger) value).compareTo(Holder.MAX_SAFE_BIG_INTEGER) > 0 || ((BigInteger) value).compareTo(Holder.MIN_SAFE_BIG_INTEGER) < 0; } else { return value.longValue() > Holder.MAX_SAFE_INTEGER || value.longValue() < Holder.MIN_SAFE_INTEGER; } }
private boolean isInfiniteOrNotANumber(Number value) { if (value instanceof Double || value instanceof Float || value instanceof DoubleAdder) { double doubleValue = value.doubleValue(); return doubleValue == Double.POSITIVE_INFINITY || doubleValue == Double.NEGATIVE_INFINITY || doubleValue == Double.NaN; } return false; }
