defer est un mot-clé fourni par golang, qui est appelé une fois que la fonction ou la méthode a terminé son exécution et son retour.
Chaque différé poussera la fonction defer dans la pile. Lorsque la fonction ou la méthode est appelée, elle sera retirée de la pile pour exécution. Par conséquent, l'ordre d'exécution de plusieurs différés est le premier entré, le dernier sorti. Le timing de déclenchement de
for i := 0; i <= 3; i++ {
defer fmt.Print(i)
}
//输出结果时 3，2，1，0defer
Le site officiel est très clair :
Une instruction "defer" invoque une fonction dont l'exécution est différée jusqu'au retour de la fonction environnante, soit parce que la fonction environnante a exécuté une instruction return , a atteint la fin du corps de sa fonction, ou parce que la goroutine correspondante panique.
- Lorsque la fonction enveloppée dans l'instruction defer revient
- Lorsque la fonction enveloppée dans l'instruction defer est exécutée jusqu'à la fin
Lorsque le courant goroutine panics
//输出结果：return前执行defer func f1() { defer fmt.Println("return前执行defer") return } //输出结果：函数执行 // 函数执行到最后 func f2() { defer fmt.Println("函数执行到最后") fmt.Println("函数执行") } //输出结果：panic前 第一个defer在Panic发生时执行，第二个defer在Panic之后声明，不能执行到 func f3() { defer fmt.Println("panic前") panic("panic中") defer fmt.Println("panic后") }
defer, return, return value ordre d'exécution
Regardons d'abord 3 exemples
func f1() int { //匿名返回值
var r int = 6
defer func() {
r *= 7
}()
return r
}
func f2() (r int) { //有名返回值
defer func() {
r *= 7
}()
return 6
}
func f3() (r int) { //有名返回值
defer func(r int) {
r *= 7
}(r)
return 6
}Le résultat de l'exécution de f1 est 6, le résultat de l'exécution de f2 est 42, le résultat de l'exécution de f3 est 6
Introduit dans la documentation officielle de golang L'ordre d'exécution de return, defer et return value :
si la fonction environnante revient via une instruction return explicite, les fonctions différées sont exécutées après que les paramètres de résultat soient définis par cette instruction return mais avant la fonction renvoie à son appelant.
1. Attribuez d'abord une valeur à la valeur de retour
2 Exécutez l'instruction defer
3 Le résultat de la fonction d'emballage return renvoie
f1 est 6. f1 est une valeur de retour anonyme.La valeur de retour anonyme est déclarée lors de l'exécution de returnPar conséquent, lorsque defer est déclaré, la valeur de retour anonyme n'est pas accessible.La modification de defer n'affectera pas la valeur de retour.
f2 attribue d'abord une valeur à la valeur de retour r, r = 6, exécute l'instruction defer, defer modifie r, r = 42, puis la fonction revient.
f3 est une valeur de retour nommée, mais comme r est utilisé comme paramètre de defer, lors de la déclaration de defer, les paramètres sont copiés et transmis, donc defer n'affectera que les paramètres locaux de la fonction defer et n'affectera pas le retour du fonction appelante.
Fermetures et fonctions anonymes
Fonction anonyme : une fonction sans nom de fonction.
Closure : Une fonction qui peut utiliser des variables dans le cadre d'une autre fonction.
for i := 0; i <= 3; i++ {
defer func() {
fmt.Print(i)
}
}
//输出结果时 3，3，3，3
因为defer函数的i是对for循环i的引用，defer延迟执行，for循环到最后i是3，到defer执行时i就
是3
for i := 0; i <= 3; i++ {
defer func(i int) {
fmt.Print(i)
}(i)
}
//输出结果时 3，2，1，0
因为defer函数的i是在defer声明的时候，就当作defer参数传递到defer函数中analyse du code source defer
le code source d'implémentation defer est dans runtime.deferproc
Ensuite, exécutez la fonction runtime.deferreturn avant le retour de la fonction.
Comprenez d'abord la structure defer :
type _defer struct {
siz int32
started bool
sp uintptr // sp at time of defer
pc uintptr
fn *funcval
_panic *_panic // panic that is running defer
link *_defer
}sp et pc pointent respectivement vers le pointeur de pile et le compteur de programme de l'appelant, fn est la fonction passée dans le mot-clé defer et Panic est la panique qui provoque l'exécution du defer.
Chaque fois qu'un mot-clé defer est rencontré, la fonction defer sera convertie en runtime.deferproc
deferproc crée une fonction de retard via newdefer et bloque cette nouvelle fonction de retard sur la liste chaînée _defer de la goroutine actuelle
func deferproc(siz int32, fn *funcval) { // arguments of fn follow fn
sp := getcallersp()
argp := uintptr(unsafe.Pointer(&fn)) + unsafe.Sizeof(fn)
callerpc := getcallerpc()
d := newdefer(siz)
if d._panic != nil {
throw("deferproc: d.panic != nil after newdefer")
}
d.fn = fn
d.pc = callerpc
d.sp = sp
switch siz {
case 0:
// Do nothing.
case sys.PtrSize:
*(*uintptr)(deferArgs(d)) = *(*uintptr)(unsafe.Pointer(argp))
default:
memmove(deferArgs(d), unsafe.Pointer(argp), uintptr(siz))
}
return0()
}newdefer supprimera d'abord un Structure _defer du deferpool de sched et current p. Si le deferpool n'a pas _defer, initialisez un nouveau _defer.
_defer est associé au g actuel, donc defer n'est valable que pour le g actuel.
d.link = gp._defer
gp._defer = d //Utilisez une liste chaînée pour connecter tous les defers du g
func newdefer(siz int32) *_defer {
var d *_defer
sc := deferclass(uintptr(siz))
gp := getg()
if sc < uintptr(len(p{}.deferpool)) {
pp := gp.m.p.ptr()
if len(pp.deferpool[sc]) == 0 && sched.deferpool[sc] != nil {
.....
d := sched.deferpool[sc]
sched.deferpool[sc] = d.link
d.link = nil
pp.deferpool[sc] = append(pp.deferpool[sc], d)
}
if n := len(pp.deferpool[sc]); n > 0 {
d = pp.deferpool[sc][n-1]
pp.deferpool[sc][n-1] = nil
pp.deferpool[sc] = pp.deferpool[sc][:n-1]
}
}
......
d.siz = siz
d.link = gp._defer
gp._defer = d
return d
}
deferreturn actuel Retirez la liste chaînée _defer du g actuel et exécutez-la. Chaque _defer appelle freedefer. pour libérer la structure _defer, et mettre la structure _defer dans le deferpool du p actuel.
analyse des performances defer
defer est très utile pour la libération des ressources, la capture de panique, etc. pendant le développement. Il est possible que certains développeurs n'aient pas pris en compte l'impact du report sur les performances des programmes et abusent du report dans leurs programmes.
Lors du test de performances, on peut constater que le report a encore un certain impact sur les performances. Conseils d'optimisation des performances Go de Yuchen 4/1, il existe quelques tests sur la surcharge supplémentaire causée par les instructions defer.
Code de test
var mu sync.Mutex
func noDeferLock() {
mu.Lock()
mu.Unlock()
}
func deferLock() {
mu.Lock()
defer mu.Unlock()
}
func BenchmarkNoDefer(b *testing.B) {
for i := 0; i < b.N; i++ {
noDeferLock()
}
}
func BenchmarkDefer(b *testing.B) {
for i := 0; i < b.N; i++ {
deferLock()
}
Résultats du test :
BenchmarkNoDefer-4 100000000 11.1 ns/op BenchmarkDefer-4 36367237 33.1 ns/op
D'après l'analyse précédente du code source, nous pouvons savoir que defer appellera d'abord deferproc, qui copiera les paramètres, et deferreturn extraira également les informations pertinentes pour retarder l'exécution. C'est mieux que d'appeler directement une déclaration, cela coûte plus cher.
Les performances du report ne sont pas élevées. Chaque report prend 20 ns si cela se produit plusieurs fois dans une fonction, la consommation de performances est de 20 ns*n.
Solution : sauf lorsque la capture d'exception est requise, le report doit être utilisé ; pour d'autres reports de recyclage de ressources, vous pouvez utiliser goto pour accéder à la zone de code de recyclage des ressources après avoir jugé l'échec. Pour les ressources concurrentes, vous pouvez libérer les ressources immédiatement après utilisation, afin que les ressources concurrentes puissent être utilisées de manière optimale.