Use AtomicInteger + mod instead of synchronizing threads in CountingS…

…ampler. (openzipkin#857)

brave/src/main/java/brave/sampler/CountingSampler.java

@@ -2,6 +2,7 @@
 
 import java.util.BitSet;
 import java.util.Random;
+import java.util.concurrent.atomic.AtomicInteger;
 
 /**
  * This sampler is appropriate for low-traffic instrumentation (ex servers that each receive <100K
@@ -29,28 +30,42 @@ public static Sampler create(final float rate) {
     return new CountingSampler(rate);
   }
 
-  private int i; // guarded by this
+  private final AtomicInteger counter;
   private final BitSet sampleDecisions;
 
   /** Fills a bitset with decisions according to the supplied rate. */
   CountingSampler(float rate) {
+    this(rate, new Random());
+  }
+
+  /**
+   * Fills a bitset with decisions according to the supplied rate with the supplied {@link Random}.
+   */
+  CountingSampler(float rate, Random random) {
+    counter = new AtomicInteger();
     int outOf100 = (int) (rate * 100.0f);
-    this.sampleDecisions = randomBitSet(100, outOf100, new Random());
+    this.sampleDecisions = randomBitSet(100, outOf100, random);
   }
 
   /** loops over the pre-canned decisions, resetting to zero when it gets to the end. */
   @Override
-  public synchronized boolean isSampled(long traceIdIgnored) {
-    boolean result = sampleDecisions.get(i++);
-    if (i == 100) i = 0;
-    return result;
+  public boolean isSampled(long traceIdIgnored) {
+    return sampleDecisions.get(mod(counter.getAndIncrement(), 100));
   }
 
   @Override
   public String toString() {
     return "CountingSampler()";
   }
 
+  /**
+   * Returns a non-negative mod.
+   */
+  static int mod(int dividend, int divisor) {
+    int result = dividend % divisor;
+    return result >= 0 ? result : divisor + result;
+  }
+
   /**
    * Reservoir sampling algorithm borrowed from Stack Overflow.
    *

instrumentation/benchmarks/src/main/java/brave/sampler/SamplerBenchmarks.java

@@ -1,6 +1,7 @@
 package brave.sampler;
 
 import com.amazonaws.xray.strategy.sampling.reservoir.Reservoir;
+import java.util.Random;
 import java.util.concurrent.TimeUnit;
 import org.openjdk.jmh.annotations.Benchmark;
 import org.openjdk.jmh.annotations.BenchmarkMode;
@@ -90,7 +91,8 @@ public static class Args {
     return SAMPLER_RATE.isSampled(args.traceId);
   }
 
-  static final Sampler SAMPLER_RATE = CountingSampler.create(SAMPLE_RATE);
+  // Use fixed-seed Random so performance of runs can be compared.
+  static final Sampler SAMPLER_RATE = new CountingSampler(SAMPLE_RATE, new Random(1000));
 
   @Benchmark public boolean sampler_rateLimited_1(Args args) {
     return SAMPLER_RATE_LIMITED.isSampled(args.traceId);