[6.9.0]

[fea]
[driver]
[时间同步算法优化]

OCH/common/biz/src/main/java/com/mogo/och/biz/time/TimeProvider.kt

@@ -13,6 +13,26 @@ import com.mogo.och.common.module.manager.logchainanalytic.OchChainLogManager
 import com.mogo.och.common.module.network.OchCommonServiceCallback
 import com.mogo.och.common.module.utils.RxUtils
 
+
+/**
+ * 当本地计算机（客户端）想要与NTP服务器同步时间时，它会发送一个时间同步请求给NTP服务器。
+ * 在这个过程中，会有四个关键的时间戳被记录：
+ * T1：客户端发送请求的时间。
+ * T2：服务器接收到请求的时间。
+ * T3：服务器发送响应的时间。
+ * T4：客户端接收到响应的时间。
+ *
+ * 计算延迟时间（Delay）：
+ * Delay是客户端和服务端之间的往返时间（RoundTrip Time），
+ * 计算公式为：Delay = [(T4 - T1) - (T3 – T2)]/2
+ *
+ * 计算时间偏差（Offset）：
+ * Offset是客户端时间与服务器时间的偏差，计算公式为：
+ * Offset = T3 + Delay - T4 = [(T2 - T1) + (T3 – T4)]/2
+ * 这个偏差可以是正数也可以是负数，表示客户端时间是快于还是慢于服务器时间。
+ *
+ *
+ */
 @Route(path = OchCommonConst.BIZ_TIME)
 class TimeProvider : TimeService {
 
@@ -20,32 +40,55 @@ class TimeProvider : TimeService {
 
     private val TAG = M_OCHCOMMON + "TimeProvider"
 
-    private var diffTime = 0L
+    private var offset = 0L
 
     private var diffTimeGetTime = 0L
 
+    private var netTime = Long.MAX_VALUE
+
     override fun loadNewTime() {
         OchChainLogManager.writeChainLogTime("时间同步", "开始时间同步")
         d(TAG, "时间同步_开始时间同步")
-        val startTime = System.currentTimeMillis()
+        val T1 = System.currentTimeMillis()
         if (ProjectUtils.isSaas()) {
             context?.let {
                 OchTimeServiceManager.queryTime(it,
                     object : OchCommonServiceCallback<TimeRespBean> {
                         override fun onSuccess(data: TimeRespBean?) {
-                            val endTime = System.currentTimeMillis()
-                            data?.data?.let { serverTime ->
-                                val netTime = (endTime - startTime) / 2
-                                val currentServerTime = serverTime + netTime
-                                diffTime = currentServerTime - endTime
-                                diffTimeGetTime = endTime
+                            val T4 = System.currentTimeMillis()
+                            var delay = 0L
+                            data?.data?.let { T3 ->
+                                delay = (T4 - T1) / 2
+                                val currentNetTime = (T4-T1)
+                                if(currentNetTime>netTime){
+                                    OchChainLogManager.writeChainLogTime(
+                                        "时间信息",
+                                        "时间延迟较上次大 放弃此次同步${currentNetTime}___上次同步网络延迟${netTime}"
+                                    )
+                                    return
+                                }
+                                netTime = currentNetTime
+                                val currentServerTime = T3 + delay
+                                offset = currentServerTime - T4
+                                diffTimeGetTime = T4
                             }
 
                             OchChainLogManager.writeChainLogTime(
                                 "时间信息",
-                                "请求时间信息成功:${data};时间差是:${diffTime}"
+                                "请求时间信息成功:${data};时间差是:${offset}"
                             )
-                            d(TAG, "时间同步_请求时间信息成功:${data};时间差是:${diffTime}")
+                            d(TAG, "时间同步_请求时间信息成功:${data};时间差是:${offset}_路上的时间:${delay}")
+                            if(netTime>3_000){
+                                // 网络延迟大 10s 同步一次
+                                RxUtils.createSubscribeOnOwnThread(60_000) {
+                                    loadNewTime()
+                                }
+                            }else{
+                                RxUtils.createSubscribeOnOwnThread(30*60_000) {
+                                    loadNewTime()
+                                }
+                            }
+
                         }
 
                         override fun onError() {
@@ -77,8 +120,8 @@ class TimeProvider : TimeService {
     }
 
     override fun getCurrentTimeStamp(): Long {
-        d(TAG,"获取时间_${System.currentTimeMillis() + diffTime}")
-        return System.currentTimeMillis() + diffTime
+        d(TAG,"获取时间_${System.currentTimeMillis() + offset}")
+        return System.currentTimeMillis() + offset
     }
 
     override fun getSynServerTime(): Long {
@@ -86,7 +129,7 @@ class TimeProvider : TimeService {
     }
 
     override fun getTimeStampDiff(): Long {
-        return diffTime
+        return offset
     }
 
 

OCH/common/common/src/main/java/com/mogo/och/common/module/biz/time/TimeManager.kt

@@ -20,7 +20,9 @@ object TimeManager {
     fun load(){
         OchChainLogManager.writeChainLogInit("初始化信息","初始化时间系统")
         d(TAG,"初始化信息_初始化时间系统")
-        BizLoopManager.setLoopFunction(TAG, LoopInfo(60*2, TimeManager::loadNewTime,immediately = true, scheduler = Schedulers.io()))
+        BizLoopManager.runInIoThread{
+            loadNewTime()
+        }
     }
 
     fun loadNewTime(){