Monotone Taktverarbeitung des Zeitpakets

Heute werfen wir hauptsächlich einen Blick auf die Zeitanwendungsmethode des Golang-Zeitpakets.

Wenn es darum geht, Uhren durch Computer zu verarbeiten, gibt es im Wesentlichen zwei Möglichkeiten:

• Wandzeit (Wandzeit)
• monotone Uhren (monotone Uhren)

Die allgemeine Regel für beide ist „Wandzeit“ wird verwendet für Zeit messen; Es gibt andere Möglichkeiten, mit Uhren umzugehen. 告知时间，而「monotonic clock」用于测量时间；除外还有其他的时钟处理方式。

如果你还不了解上面两种时钟的概念，那么我推荐你可以先访问：你真的了解计算机的时间吗？^[1]这篇文章详细说明了这两种时钟的来历。

在看下面的内容之前，我会认为你已经知道了什么是 墙上时钟 和 单调时钟。

我接下来看一段 time.Time

Wenn Sie die Konzepte der beiden oben genannten Uhren nicht verstehen, empfehle ich Ihnen, Folgendes zu besuchen: Verstehen Sie die Computerzeit wirklich? ^[1]Dieser Artikel beschreibt die Ursprünge dieser beiden Uhren.

Bevor ich den folgenden Inhalt lese, gehe ich davon aus, dass Sie bereits wissen, was Wanduhr und Monotone Uhr.

Als nächstes werde ich mir einen Absatz ansehenZeit repräsentiert einen Zeitpunkt mit Nanosekundengenauigkeit.

Programme, die Zeiten verwenden, sollten diese im Allgemeinen als Werte und nicht als Zeiger speichern und übergeben. Mit anderen Worten: Der Typ der Zeitvariablen und Strukturfelder sollte time.Time und nicht *time.Time sein. 🎜🎜Ein Zeitwert kann von mehreren Goroutinen gleichzeitig verwendet werden, außer GobDecode, UnmarshalBinary, Die Methoden UnmarshalJSON und UnmarshalText sind nicht parallelitätssicher. 🎜🎜Zeitmomente können mit den Methoden Vorher, Nachher und Gleich verglichen werden. Die Sub-Methode subtrahiert zwei Zeitpunkte und erzeugt so eine Dauer. Die Add-Methode fügt einer Zeit eine Dauer hinzu und erzeugt so eine Zeit. 🎜

Der Nullwert des Zeittyps ist der 1. Januar, Jahr 1, 00:00:00.000000000 UTC. Da dieser Zeitpunkt in der Praxis wahrscheinlich nicht auftritt, bietet die IsZero-Methode eine einfache Möglichkeit, Zeiten zu erkennen, die nicht explizit initialisiert wurden.

Jede Zeit ist einem Ort zugeordnet, der bei der Berechnung der Zeitdarstellung referenziert wird. Zum Beispiel in den Methoden Format, Stunde und Jahr. Die Methoden Local, UTC und In geben die Zeit an einem bestimmten Ort zurück. Eine solche Änderung der Position verändert nur die Darstellung; sie verändert nicht den Darstellungszeitpunkt und hat daher keinen Einfluss auf die im vorherigen Absatz beschriebenen Berechnungen.

Der von den Methoden GobEncode, MarshalBinary, MarshalJSON und MarshalText gespeicherte Zeitwert stellt den Offset dar, an dem Time.Location gespeichert wird, speichert jedoch nicht den Standortnamen. Daher gehen ihnen Informationen über die Sommerzeit verloren.

Zusätzlich zur erforderlichen „Wanduhr“-Anzeige kann die Zeit auch eine optionale Anzeige der monotonen Uhr des aktuellen Prozesses enthalten, um zusätzliche Vergleichs- oder Subtraktionsgenauigkeit zu ermöglichen. Weitere Informationen finden Sie im Abschnitt „Monotonic Clocks“ in der Paketdokumentation.

Bitte beachten Sie, dass Go == 运算符不仅比较时间瞬间，还比较位置和单调时钟读数。因此，在没有首先保证已为所有值设置相同位置的情况下，不应将时间值用作地图或数据库键，这可以通过使用 UTC 或本地方法来实现，并且单调时钟读数已被剥离设置 t = t.Round(0)。一般来说，比起 t == u，更喜欢 t.Equal(u)，因为 t.Equal 使用最准确的比较可用并且正确处理只有一个参数具有单调时钟读数的情况。

到这里官方提供的 time.TIme 的介绍已经说完了。我们来一起看一下 Time 的结构是什么样的：

type Time struct {
 wall uint64
 ext  int64

 loc *Location
}

wall 它的最高位包含一个1位标志。表示hasMonotonic，然后是33位用于跟踪秒数；最后是30位，用于跟踪纳秒，范围为[0，999999999]。

如果该hasMonotonic位为0，则33位字段为零，并且ext 存储自1年1月1日以来的完整带符号的64位wall

Dies ist das Ende der offiziellen Einführung in time.TIme. Schauen wir uns an, wie die Struktur der Zeit aussieht: 🎜

// Now returns the current local time.
func Now() Time {
 sec, nsec, mono := now() // 返回对应的秒数，纳秒数，单调时钟数
 mono -= startNano
 sec += unixToInternal - minWall
 if uint64(sec)>>33 != 0 { // 判断如果秒数右移33位后大于0，说明不能采用单调时钟。
  return Time{uint64(nsec), sec + minWall, Local} // 按照 `wall` 时钟返回
 }
  
  // 返回 `wall` 时钟和 `monotonic` 时钟信息
 return Time{hasMonotonic | uint64(sec)<<nsecShift | uint64(nsec), mono, Local}
}

🎜wall Es enthält ein 1-Bit-Flag in seinem höchsten Bit. RepräsentiertwallSekunden. 🎜

如果该hasMonotonic位为1，则33位字段存储自1885年1月1日以来的无符号的wall秒数，而ext保留有符号的64位单调时钟读数，距离进程开始的时间为纳秒。这是大多数代码中通常发生的情况。

我们来通过 time.now() 函数来查看其中的区别：

// Now returns the current local time.
func Now() Time {
 sec, nsec, mono := now() // 返回对应的秒数，纳秒数，单调时钟数
 mono -= startNano
 sec += unixToInternal - minWall
 if uint64(sec)>>33 != 0 { // 判断如果秒数右移33位后大于0，说明不能采用单调时钟。
  return Time{uint64(nsec), sec + minWall, Local} // 按照 `wall` 时钟返回
 }
  
  // 返回 `wall` 时钟和 `monotonic` 时钟信息
 return Time{hasMonotonic | uint64(sec)<<nsecShift | uint64(nsec), mono, Local}
}

通过这个例子我们可以看到在time包中对于时间差的计算基本都会采用单调时钟和墙上时钟的兼容。

• func (t Time) After(u Time) bool {...}
• func (t Time) Before(u Time) bool {...}
• func (t Time) Equal(u Time) bool {...}
• func (t Time) Add(d Duration) Time {...}
• func (t Time) Sub(u Time) Duration {...}
• func Since(t Time) Duration {...}
• func Until(t Time) Duration {...}

对于增加修改时间计算会清除单调时钟，因为后面调用的是 unixTime 函数：

func unixTime(sec int64, nsec int32) Time {
 return Time{uint64(nsec), sec + unixToInternal, Local}
}

不会计算单调时钟的秒数，如下：

?? .}

• func UnixMilli(sec int64, nsec int64) Time {...}
• func UnixMicro(sec int64, nsec int64) Time {...}
• func (t Time) AddDate (Jahre int, Monate int, Tage int) Zeit {...}
• Ich hoffe, dass Sie nach dem Lesen dieser Konzepte und Kenntnisse das Zeitpaket besser nutzen können.

Das obige ist der detaillierte Inhalt vonMonotone Taktverarbeitung des Zeitpakets. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!