auto commit

C#.NET/source/Yitter.IdGenerator/Core/SnowWorkerM1.cs

@@ -274,19 +274,20 @@ namespace Yitter.IdGenerator
                 if (_TurnBackTimeTick < 1)
                 {
                     _TurnBackTimeTick = _LastTimeTick - 1;
+
+                    _TurnBackIndex++;
+                    // 每毫秒序列数的前5位是预留位，0用于手工新值，1-4是时间回拨次序
+                    // 支持4次回拨次序（避免回拨重叠导致ID重复），可无限次回拨（次序循环使用）。
+                    if (_TurnBackIndex > 4)
+                    {
+                        _TurnBackIndex = 1;
+                    }
+
 #if DEBUG
                     BeginTurnBackAction(_TurnBackTimeTick);
 #endif
                 }
 
-                _TurnBackIndex++;
-                // 每毫秒序列数的前5位是预留位，0用于手工新值，1-4是时间回拨次序
-                // 支持4次回拨次序（避免回拨重叠导致ID重复），可无限次回拨（次序循环使用）。
-                if (_TurnBackIndex > 4)
-                {
-                    _TurnBackIndex = 1;
-                }
-
                 //Thread.Sleep(1);
                 return CalcTurnBackId(_TurnBackTimeTick);
             }

C/source/idgen/SnowWorkerM1.c

@@ -26,9 +26,9 @@ static int64_t CalcTurnBackId(SnowFlakeWorker *worker);
 
 
 static inline void EndOverCostAction(int64_t useTimeTick, SnowFlakeWorker *worker) {
-    if (worker->_TermIndex > 10000) {
-        worker->_TermIndex = 0;
-    }
+    // if (worker->_TermIndex > 10000) {
+    //     worker->_TermIndex = 0;
+    // }
 }
 
 static inline int64_t NextOverCostId(SnowFlakeWorker *worker) {
@@ -69,11 +69,12 @@ static inline int64_t NextNormalId(SnowFlakeWorker *worker) {
     if (currentTimeTick < worker->_LastTimeTick) {
         if (worker->_TurnBackTimeTick < 1) {
             worker->_TurnBackTimeTick = worker->_LastTimeTick - 1;
-        }
-
-        worker->_TurnBackIndex++;
-        if (worker->_TurnBackIndex > 4) {
-            worker->_TurnBackIndex = 1;
+            worker->_TurnBackIndex++;
+            // 每毫秒序列数的前 5 位是预留位，0 用于手工新值，1-4 是时间回拨次序
+            // 支持 4 次回拨次序（避免回拨重叠导致 ID 重复），可无限次回拨（次序循环使用）。
+            if (worker->_TurnBackIndex > 4) {
+                worker->_TurnBackIndex = 1;
+            }
         }
 
         // usleep(1000); // 暂停1ms

Go/source/idgen/SnowWorkerM1.go

@@ -170,16 +170,15 @@ func (m1 *SnowWorkerM1) NextNormalId() int64 {
 	if currentTimeTick < m1._LastTimeTick {
 		if m1._TurnBackTimeTick < 1 {
 			m1._TurnBackTimeTick = m1._LastTimeTick - 1
+			m1._TurnBackIndex++
+			// 每毫秒序列数的前5位是预留位，0用于手工新值，1-4是时间回拨次序
+			// 支持4次回拨次序（避免回拨重叠导致ID重复），可无限次回拨（次序循环使用）。
+			if m1._TurnBackIndex > 4 {
+				m1._TurnBackIndex = 1
+			}
 			m1.BeginTurnBackAction(m1._TurnBackTimeTick)
 		}
 
-		m1._TurnBackIndex++
-		// 每毫秒序列数的前5位是预留位，0用于手工新值，1-4是时间回拨次序
-		// 支持4次回拨次序（避免回拨重叠导致ID重复），可无限次回拨（次序循环使用）。
-		if m1._TurnBackIndex > 4 {
-			m1._TurnBackIndex = 1
-		}
-
 		// time.Sleep(time.Duration(1) * time.Millisecond)
 		return m1.CalcTurnBackId(m1._TurnBackTimeTick)
 	}

Java/source/src/main/java/com/github/yitter/core/SnowWorkerM1.java

@@ -81,9 +81,9 @@ public class SnowWorkerM1 implements ISnowWorker {
     }
 
     private void EndOverCostAction(long useTimeTick) {
-        if (_TermIndex > 10000) {
-            _TermIndex = 0;
-        }
+        // if (_TermIndex > 10000) {
+        //     _TermIndex = 0;
+        // }
     }
 
     private void BeginTurnBackAction(long useTimeTick) {
@@ -141,14 +141,13 @@ public class SnowWorkerM1 implements ISnowWorker {
         if (currentTimeTick < _LastTimeTick) {
             if (_TurnBackTimeTick < 1) {
                 _TurnBackTimeTick = _LastTimeTick - 1;
-                BeginTurnBackAction(_TurnBackTimeTick);
-            }
-
-            _TurnBackIndex++;
-            // 每毫秒序列数的前5位是预留位，0用于手工新值，1-4是时间回拨次序
-            // 支持4次回拨次序（避免回拨重叠导致ID重复），可无限次回拨（次序循环使用）。
-            if (_TurnBackIndex > 4) {
-                _TurnBackIndex = 1;
+                _TurnBackIndex++;
+                // 每毫秒序列数的前5位是预留位，0用于手工新值，1-4是时间回拨次序
+                // 支持4次回拨次序（避免回拨重叠导致ID重复），可无限次回拨（次序循环使用）。
+                if (_TurnBackIndex > 4) {
+                    _TurnBackIndex = 1;
+                }
+                //BeginTurnBackAction(_TurnBackTimeTick);
             }
 
             // try {

JavaScript/index.js

@@ -136,16 +136,15 @@ class Genid {
         if (currentTimeTick < this._LastTimeTick) {
             if (this._TurnBackTimeTick < 1) {
                 this._TurnBackTimeTick = this._LastTimeTick - 1;
+                this._TurnBackIndex++;
+                // 每毫秒序列数的前 5 位是预留位，0 用于手工新值，1-4 是时间回拨次序
+                // 支持 4 次回拨次序（避免回拨重叠导致 ID 重复），可无限次回拨（次序循环使用）。
+                if (this._TurnBackIndex > 4) {
+                    this._TurnBackIndex = 1;
+                }
                 this.BeginTurnBackAction(this._TurnBackTimeTick);
             }
             
-            this._TurnBackIndex++;
-            // 每毫秒序列数的前 5 位是预留位，0 用于手工新值，1-4 是时间回拨次序
-            // 支持 4 次回拨次序（避免回拨重叠导致 ID 重复），可无限次回拨（次序循环使用）。
-            if (this._TurnBackIndex > 4) {
-                this._TurnBackIndex = 1;
-            }
-            
             return this.CalcTurnBackId(this._TurnBackTimeTick);
         }
         

PHP/src/snowflake/snowflake.c

@@ -178,14 +178,13 @@ static inline uint64_t NextNormalId(snowflake *flake)
 		if (flake->_TurnBackTimeTick < 1)
 		{
 			flake->_TurnBackTimeTick = flake->_LastTimeTick - 1;
+			flake->_TurnBackIndex++;
+			if (flake->_TurnBackIndex > 4)
+			{
+				flake->_TurnBackIndex = 1;
+			}
 		}
-		
-		flake->_TurnBackIndex++;
-		if (flake->_TurnBackIndex > 4)
-		{
-			flake->_TurnBackIndex = 1;
-		}
-		
+
 		return CalcTurnBackId(flake);
 	}
 	if (flake->_TurnBackTimeTick > 0)

Python/source/snowflake_m1.py

@@ -86,11 +86,11 @@ class SnowFlakeM1(SnowFlake):
         if current_time_tick < self.__last_time_tick:
             if self.__turn_back_time_tick < 1:
                 self.__turn_back_time_tick = self.__last_time_tick - 1
-            self.__turn_back_index += 1
-            # 每毫秒序列数的前5位是预留位, 0用于手工新值, 1-4是时间回拨次序
-            # 支持4次回拨次序（避免回拨重叠导致ID重复）, 可无限次回拨（次序循环使用）。
-            if self.__turn_back_index > 4:
-                self.__turn_back_index = 1
+                self.__turn_back_index += 1
+                # 每毫秒序列数的前5位是预留位, 0用于手工新值, 1-4是时间回拨次序
+                # 支持4次回拨次序（避免回拨重叠导致ID重复）, 可无限次回拨（次序循环使用）。
+                if self.__turn_back_index > 4:
+                    self.__turn_back_index = 1
 
             return self.__calc_turn_back_id(self.__turn_back_time_tick)
 

Rust/source/src/idgen/snow_worker_m1.rs

@@ -170,9 +170,9 @@ impl SnowWorkerM1 {
     fn BeginOverCostAction(&self, useTimeTick: i64) {}
 
     fn EndOverCostAction(&mut self, useTimeTick: i64) {
-        if self._TermIndex > 10000 {
-            self._TermIndex = 0;
-        }
+        // if self._TermIndex > 10000 {
+        //     self._TermIndex = 0;
+        // }
     }
 
     fn BeginTurnBackAction(&self, useTimeTick: i64) {}
@@ -226,16 +226,15 @@ impl SnowWorkerM1 {
         if currentTimeTick < self._LastTimeTick {
             if self._TurnBackTimeTick < 1 {
                 self._TurnBackTimeTick = self._LastTimeTick - 1;
+                self._TurnBackIndex += 1;
+                // 每毫秒序列数的前5位是预留位，0用于手工新值，1-4是时间回拨次序
+                // 支持4次回拨次序（避免回拨重叠导致ID重复），可无限次回拨（次序循环使用）。
+                if self._TurnBackIndex > 4 {
+                    self._TurnBackIndex = 1;
+                }
                 self.BeginTurnBackAction(self._TurnBackTimeTick);
             }
 
-            self._TurnBackIndex += 1;
-            // 每毫秒序列数的前5位是预留位，0用于手工新值，1-4是时间回拨次序
-            // 支持4次回拨次序（避免回拨重叠导致ID重复），可无限次回拨（次序循环使用）。
-            if self._TurnBackIndex > 4 {
-                self._TurnBackIndex = 1;
-            }
-
             // thread::sleep(std::time::Duration::from_millis(1));
             return self.CalcTurnBackId(self._TurnBackTimeTick);
         }

TypeScript/snowflakeIdv1.ts

@@ -243,15 +243,14 @@ export class snowflakeIdv1 {
         if (currentTimeTick < this._LastTimeTick) {
             if (this._TurnBackTimeTick < 1) {
                 this._TurnBackTimeTick = this._LastTimeTick - BigInt(1)
+                this._TurnBackIndex++
+                // 每毫秒序列数的前 5 位是预留位，0 用于手工新值，1-4 是时间回拨次序
+                // 支持 4 次回拨次序（避免回拨重叠导致 ID 重复），可无限次回拨（次序循环使用）。
+                if (this._TurnBackIndex > 4)
+                    this._TurnBackIndex = 1
                 this.BeginTurnBackAction(this._TurnBackTimeTick)
             }
 
-            this._TurnBackIndex++
-            // 每毫秒序列数的前 5 位是预留位，0 用于手工新值，1-4 是时间回拨次序
-            // 支持 4 次回拨次序（避免回拨重叠导致 ID 重复），可无限次回拨（次序循环使用）。
-            if (this._TurnBackIndex > 4)
-                this._TurnBackIndex = 1
-
             return this.CalcTurnBackId(this._TurnBackTimeTick)
         }
         

zzz-OtherLanguages/D/source/yitter/core/SnowWorkerM1.d

@@ -83,9 +83,9 @@ class SnowWorkerM1 : ISnowWorker {
     }
 
     private void EndOverCostAction(long useTimeTick) {
-        if (_TermIndex > 10000) {
-            _TermIndex = 0;
-        }
+        //if (_TermIndex > 10000) {
+        //    _TermIndex = 0;
+        //}
     }
 
     private void BeginTurnBackAction(long useTimeTick) {
@@ -143,16 +143,14 @@ class SnowWorkerM1 : ISnowWorker {
         if (currentTimeTick < _LastTimeTick) {
             if (_TurnBackTimeTick < 1) {
                 _TurnBackTimeTick = _LastTimeTick - 1;
+                _TurnBackIndex++;
+                // 每毫秒序列数的前5位是预留位，0用于手工新值，1-4是时间回拨次序
+                // 最多4次回拨（防止回拨重叠）
+                if (_TurnBackIndex > 4) {
+                    _TurnBackIndex = 1;
+                }
                 BeginTurnBackAction(_TurnBackTimeTick);
-            }
-
-            _TurnBackIndex++;
-
-            // 每毫秒序列数的前5位是预留位，0用于手工新值，1-4是时间回拨次序
-            // 最多4次回拨（防止回拨重叠）
-            if (_TurnBackIndex > 4) {
-                _TurnBackIndex = 1;
-            }
+            }           
 
 //            try {
 //                 Thread.sleep(1);

zzz-OtherLanguages/V/source/core/SnowWorkerM1.v

@@ -130,16 +130,15 @@ fn (mut m1 SnowWorkerM1) next_normal_id() u64 {
 	if current_time_tick < m1.last_time_tick {
 		if m1.turn_back_timetick < 1 {
 			m1.turn_back_timetick = m1.last_time_tick - 1
+			m1.turnback_index++
+			// 每毫秒序列数的前5位是预留位，0用于手工新值，1-4是时间回拨次序
+			// 最多4次回拨（防止回拨重叠）
+			if m1.turnback_index > 4 {
+				m1.turnback_index = 1
+			}
 			// m1.begin_turn_back_action(m1.turn_back_timetick)
 		}
 
-		m1.turnback_index++
-		// 每毫秒序列数的前5位是预留位，0用于手工新值，1-4是时间回拨次序
-		// 最多4次回拨（防止回拨重叠）
-		if m1.turnback_index > 4 {
-			m1.turnback_index = 1
-		}
-
 		return m1.calc_turn_back_id()
 	}
 	// 时间追平时，turn_back_timetick清零