Traitement d'horloge monotone du paquet de temps

Aujourd'hui, nous allons principalement examiner la méthode d'application du temps du package Golang Time.

En ce qui concerne le traitement des horloges par les ordinateurs, il existe deux manières principales :

• l'heure murale (heure murale)
• horloges monotones (horloges monotones)

La règle générale pour les deux est "l'heure murale" est utilisé pour Dites au time, et "horloge monotone" est utilisée Mesurer le temps; Il existe d'autres façons de gérer les horloges. 告知时间，而「monotonic clock」用于测量时间；除外还有其他的时钟处理方式。

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

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

我接下来看一段 time.Time

Si vous ne comprenez pas les concepts des deux horloges ci-dessus, alors je vous recommande de visiter : Comprenez-vous vraiment l'heure de l'ordinateur ? ^[1]Cet article détaille les origines de ces deux horloges.

Avant de lire le contenu ci-dessous, je suppose que vous savez déjà ce que horloge murale et Horloge monotone.

Je vais regarder un paragraphe ensuitetime.Time (via traduction automatique) :

Le temps représente un instant avec une précision de la nanoseconde.

Les programmes qui utilisent des temps doivent généralement les stocker et les transmettre sous forme de valeurs plutôt que de pointeurs. En d’autres termes, le type des variables temporelles et des champs de structure doit être time.Time et non *time.Time. 🎜🎜Une valeur Time peut être utilisée par plusieurs goroutines en même temps, à l'exception de GobDecode, UnmarshalBinary, Les méthodes UnmarshalJSON et UnmarshalText ne sont pas sécurisées en matière de concurrence. 🎜🎜Les instants de temps peuvent être comparés à l'aide des méthodes Avant, Après et Égal. La méthode Sub soustrait deux instants, produisant une durée. La méthode Add ajoute une durée à une heure, produisant une heure. 🎜

La valeur zéro du type Time est le 1er janvier de l’année 1, 00:00:00.000000000 UTC. Comme il est peu probable que cette heure se produise dans la pratique, la méthode IsZero fournit un moyen simple de détecter les heures qui n'ont pas été explicitement initialisées.

Chaque Heure est associée à un Lieu, qui est référencé lors du calcul de la représentation du temps, Par exemple dans les méthodes Format, Heure et Année. Les méthodes Local, UTC et In renvoient l'heure à un emplacement spécifique. Changer ainsi la position ne change que la présentation ; cela ne change pas le moment de la représentation et n'affecte donc pas les calculs décrits dans le paragraphe précédent.

La valeur temporelle enregistrée par les méthodes GobEncode, MarshalBinary, MarshalJSON et MarshalText représente le décalage auquel Time.Location est stocké, mais ne stocke pas le nom de l'emplacement. Par conséquent, ils perdent des informations sur l’heure d’été.

En plus de la lecture requise de « l'horloge murale », l'heure peut également contenir une lecture facultative de l'horloge monotone du processus en cours pour fournir une précision supplémentaire de comparaison ou de soustraction. Consultez la section « Horloges monotones » dans la documentation du package pour plus de détails.

Veuillez noter que Go == compare non seulement les instants, mais également les positions et les lectures d'horloge monotones. Par conséquent, les valeurs temporelles ne doivent pas être utilisées comme clés de carte ou de base de données sans s'assurer au préalable que la même position a été définie pour toutes les valeurs, cela peut être réalisé en utilisant UTC ou des méthodes natives, et que la lecture monotone de l'horloge a été supprimée. réglage t = t.Round(0). En général, préférez t.Equal(u) à t == u car t.Equal utilise la comparaison la plus précise disponible et gère correctement le cas où un seul paramètre a une lecture d'horloge monotone. == 运算符不仅比较时间瞬间，还比较位置和单调时钟读数。因此，在没有首先保证已为所有值设置相同位置的情况下，不应将时间值用作地图或数据库键，这可以通过使用 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

C'est la fin de l'introduction officielle à time.TIme. Voyons à quoi ressemble la structure de Time : 🎜

// 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 Il contient un indicateur de 1 bit dans son bit le plus élevé. ReprésentehasMonotonic</code >, puis 33 bits pour suivre les secondes ; et enfin 30 bits pour suivre les nanosecondes dans la plage [0, 999999999]. 🎜🎜Si le bit hasMonotonic est 0, alors le champ 33 bits est zéro et <code style="font-size: 14px;overflow-wrap: break-word;padding: 2px 4px;border-radius: 4px;margin- droite : 2px;marge gauche: 2px;couleur: rgb(30, 107, 184);couleur d'arrière-plan: rgba(27, 31, 35, 0.05);famille de polices: "Operator Mono", Consolas, Monaco, Menlo , monospace;word-break: break-all;">ext stocke le murSecondes. 🎜

如果该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 Date(année int, mois Mois, jour, heure, min, sec, nsec int, loc *Emplacement) Heure {...}
• func Unix(sec int64, nsec int64) Heure {.. .}
• func UnixMilli(sec int64, nsec int64) Heure {...}
• func UnixMicro(sec int64, nsec int64) Heure {...}
• func (t Time) AddDate (années int, mois int, jours int) Temps {...}

J'espère qu'après avoir lu ces concepts et connaissances, vous deviendrez plus compétent dans l'utilisation du package time.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!