Remove CAS and make state volatile

Signed-off-by: Jason Joo <[email protected]>

Author: jasonjoo2010

sentinel-core/src/main/java/com/alibaba/csp/sentinel/util/TimeUtil.java

@@ -17,7 +17,6 @@
 
 import java.util.List;
 import java.util.concurrent.TimeUnit;
-import java.util.concurrent.atomic.AtomicLong;
 
 import com.alibaba.csp.sentinel.log.RecordLog;
 import com.alibaba.csp.sentinel.slots.statistic.base.LeapArray;
@@ -42,6 +41,8 @@
  */
 public final class TimeUtil implements Runnable {
     private static final long CHECK_INTERVAL = 3000;
+    private static final long HITS_LOWER_BOUNDARY = 800;
+    private static final long HITS_UPPER_BOUNDARY = 1200;
 
     public static enum STATE {
         IDLE, PREPARE, RUNNING;
@@ -59,9 +60,12 @@ public LongAdder getReads() {
     private static TimeUtil INSTANCE;
 
     private volatile long currentTimeMillis;
-    private AtomicLong lastCheck = new AtomicLong();
+    private volatile STATE state = STATE.IDLE;
+    
     private LeapArray<Statistic> statistics;
-    private STATE state = STATE.IDLE;
+    
+    // thread private variables
+    private long lastCheck = 0;
 
     static {
         INSTANCE = new TimeUtil();
@@ -85,6 +89,7 @@ protected WindowWrap<Statistic> resetWindowTo(WindowWrap<Statistic> windowWrap,
             }
         };
         this.currentTimeMillis = System.currentTimeMillis();
+        this.lastCheck = this.currentTimeMillis;
         Thread daemon = new Thread(this);
         daemon.setDaemon(true);
         daemon.setName("sentinel-time-tick-thread");
@@ -155,24 +160,20 @@ public Tuple2<Long, Long> currentQps(long now) {
 
     /**
      * Check and operate the state if necessary.
-     * It deals concurrency.
+     * ATTENTION: It's called in daemon thread.
      */
     private void check() {
         long now = currentTime(true);
-        long last = this.lastCheck.get();
         // every period
-        if (now - last < CHECK_INTERVAL) {
-            return;
-        }
-        // concurrent
-        if (!this.lastCheck.compareAndSet(last, now)) {
+        if (now - this.lastCheck < CHECK_INTERVAL) {
             return;
         }
+        this.lastCheck = now;
         Tuple2<Long, Long> qps = currentQps(now);
-        if (this.state == STATE.IDLE && qps.r1 > 1200) {
+        if (this.state == STATE.IDLE && qps.r1 > HITS_UPPER_BOUNDARY) {
             RecordLog.info("TimeUtil switches to PREPARE for better performance, reads={}/s, writes={}/s", qps.r1, qps.r2);
             this.state = STATE.PREPARE;
-        } else if (this.state == STATE.RUNNING && qps.r1 < 800) {
+        } else if (this.state == STATE.RUNNING && qps.r1 < HITS_LOWER_BOUNDARY) {
             RecordLog.info("TimeUtil switches to IDLE due to not enough load, reads={}/s, writes={}/s", qps.r1, qps.r2);
             this.state = STATE.IDLE;
         }

sentinel-core/src/test/java/com/alibaba/csp/sentinel/util/TimeUtilTest.java

@@ -49,35 +49,37 @@ private void waitFor(int step, int seconds) throws InterruptedException {
     public void test() throws InterruptedException {
         final AtomicInteger delayTime = new AtomicInteger(10);
         final AtomicBoolean shouldShutdown = new AtomicBoolean();
-        new Thread(new Runnable() {
-            
-            @Override
-            public void run() {
-                long last = 0;
-                while (true) {
-                    if (shouldShutdown.get()) {
-                        break;
-                    }
-                    long now = TimeUtil.currentTimeMillis();
-                    int delay = delayTime.get();
-                    if (delay < 1) {
+        for (int i = 0; i < 10; i ++) {
+            new Thread(new Runnable() {
+                
+                @Override
+                public void run() {
+                    long last = 0;
+                    while (true) {
+                        if (shouldShutdown.get()) {
+                            break;
+                        }
+                        long now = TimeUtil.currentTimeMillis();
+                        int delay = delayTime.get();
+                        if (delay < 1) {
+                            if (last > now) {
+                                System.err.println("wrong value");
+                            }
+                            last = now;
+                            continue;
+                        }
+                        try {
+                            Thread.sleep(delay);
+                        } catch (InterruptedException e) {
+                        }
                         if (last > now) {
-                            System.err.println("wrong value");
+                            System.err.println("incorrect value");
                         }
                         last = now;
-                        continue;
                     }
-                    try {
-                        Thread.sleep(delay);
-                    } catch (InterruptedException e) {
-                    }
-                    if (last > now) {
-                        System.err.println("incorrect value");
-                    }
-                    last = now;
                 }
-            }
-        }).start();
+            }).start();
+        }
         Tuple2<Long, Long> qps;
         waitFor(1, 4);
         // initial state