ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/jsr166/jsr166/src/test/tck/DoubleAccumulatorTest.java
(Generate patch)

Comparing jsr166/src/test/tck/DoubleAccumulatorTest.java (file contents):
Revision 1.7 by jsr166, Sun Apr 23 03:14:10 2017 UTC vs.
Revision 1.8 by jsr166, Sun Apr 23 04:08:48 2017 UTC

# Line 7 | Line 7
7   import java.util.concurrent.Executors;
8   import java.util.concurrent.ExecutorService;
9   import java.util.concurrent.Phaser;
10 + import java.util.concurrent.ThreadLocalRandom;
11   import java.util.concurrent.atomic.DoubleAccumulator;
12  
13   import junit.framework.Test;
# Line 124 | Line 125 | public class DoubleAccumulatorTest exten
125       * accumulates by multiple threads produce correct result
126       */
127      public void testAccumulateAndGetMT() {
128 <        final int incs = 1000000;
129 <        final int nthreads = 4;
130 <        final ExecutorService pool = Executors.newCachedThreadPool();
131 <        DoubleAccumulator a = new DoubleAccumulator(Double::max, 0.0);
132 <        Phaser phaser = new Phaser(nthreads + 1);
133 <        for (int i = 0; i < nthreads; ++i)
134 <            pool.execute(new AccTask(a, phaser, incs));
134 <        phaser.arriveAndAwaitAdvance();
135 <        phaser.arriveAndAwaitAdvance();
136 <        double expected = incs - 1;
137 <        double result = a.get();
138 <        assertEquals(expected, result);
139 <        pool.shutdown();
140 <    }
141 <
142 <    static final class AccTask implements Runnable {
143 <        final DoubleAccumulator acc;
144 <        final Phaser phaser;
145 <        final int incs;
146 <        volatile double result;
147 <        AccTask(DoubleAccumulator acc, Phaser phaser, int incs) {
148 <            this.acc = acc;
149 <            this.phaser = phaser;
150 <            this.incs = incs;
151 <        }
152 <
153 <        public void run() {
128 >        final DoubleAccumulator acc
129 >            = new DoubleAccumulator((x, y) -> x + y, 0.0);
130 >        final int nThreads = ThreadLocalRandom.current().nextInt(1, 5);
131 >        final Phaser phaser = new Phaser(nThreads + 1);
132 >        final int incs = 1_000_000;
133 >        final double total = nThreads * incs/2.0 * (incs - 1); // Gauss
134 >        final Runnable task = () -> {
135              phaser.arriveAndAwaitAdvance();
136 <            DoubleAccumulator a = acc;
137 <            for (int i = 0; i < incs; ++i)
138 <                a.accumulate(i);
139 <            result = a.get();
136 >            for (int i = 0; i < incs; i++) {
137 >                acc.accumulate((double) i);
138 >                assertTrue(acc.get() <= total);
139 >            }
140              phaser.arrive();
141 +        };
142 +        final ExecutorService p = Executors.newCachedThreadPool();
143 +        try (PoolCleaner cleaner = cleaner(p)) {
144 +            for (int i = nThreads; i-->0; )
145 +                p.execute(task);
146 +            phaser.arriveAndAwaitAdvance();
147 +            phaser.arriveAndAwaitAdvance();
148 +            assertEquals(total, acc.get());
149          }
150      }
151  

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines