Defer ist ein von Golang bereitgestelltes Schlüsselwort, das aufgerufen wird, nachdem die Funktion oder Methode die Ausführung abgeschlossen hat und zurückkehrt.
Bei jedem Defer wird die Defer-Funktion in den Stapel verschoben. Wenn die Funktion oder Methode aufgerufen wird, wird sie zur Ausführung aus dem Stapel genommen. Der auslösende Zeitpunkt von
for i := 0; i <= 3; i++ {
defer fmt.Print(i)
}
//输出结果时 3，2，1，0defer
Die offizielle Website macht es sehr deutlich:
Eine „defer“-Anweisung ruft eine Funktion auf, deren Ausführung auf den Moment verschoben wird, in dem die umgebende Funktion zurückkehrt, entweder weil die umgebende Funktion eine Return-Anweisung ausgeführt hat , das Ende seines Funktionskörpers erreicht hat oder weil die entsprechende Goroutine in Panik gerät.
- Wenn die in die Defer-Anweisung eingeschlossene Funktion zurückkehrt
- Wenn die in die Defer-Anweisung eingeschlossene Funktion bis zum Ende ausgeführt wird
Wenn die aktuelle Goroutine gerät in Panik 6
Eingeführt in der offiziellen Dokumentation von Golang. Die Ausführungsreihenfolge von Return, Defer und Return Value: Wenn die umgebende Funktion über eine explizite Return-Anweisung zurückkehrt, werden verzögerte Funktionen ausgeführt, nachdem alle Ergebnisparameter durch diese Return-Anweisung festgelegt wurden, aber vor der Funktion kehrt zu seinem Aufrufer zurück.
1. Weisen Sie zunächst dem Rückgabewert einen Wert zu
2. Führen Sie die Defer-Anweisung aus
3. Das Ergebnis der Wrapping-Funktion return
f1 ist 6. f1 ist ein anonymer Rückgabewert, der bei der Ausführung von „defer“ deklariert wird. Daher kann auf den anonymen Rückgabewert nicht zugegriffen werden. f2 weist zuerst dem Rückgabewert r, r = 6, einen Wert zu, führt die Defer-Anweisung aus, defer ändert r, r = 42, und dann kehrt die Funktion zurück. f3 ist ein benannter Rückgabewert, aber da r als Parameter von defer verwendet wird, werden die Parameter beim Deklarieren von defer kopiert und übergeben, sodass defer nur die lokalen Parameter der defer-Funktion und nicht die Rückgabe von defer beeinflusst Aufrufwert.
Abschlüsse und anonyme Funktionen
Anonyme Funktion: eine Funktion ohne Funktionsnamen. Abschluss: Eine Funktion, die Variablen im Rahmen einer anderen Funktion verwenden kann.
//输出结果：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后")
}
Quellcode-Analyse aufschieben
Führen Sie dann die Funktion runtime.deferreturn aus, bevor die Funktion zurückkehrt. Verstehen Sie zunächst die Defer-Struktur:
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
}sp und pc zeigen auf den Stapelzeiger bzw. den Programmzähler des Aufrufers, fn ist die im Schlüsselwort defer übergebene Funktion und Panic ist die Panik, die die Ausführung von defer verursacht.
Jedes Mal, wenn ein Defer-Schlüsselwort angetroffen wird, wird die Defer-Funktion in runtime.deferproc umgewandeltdeferproc erstellt über newdefer eine Verzögerungsfunktion und hängt diese neue Verzögerungsfunktion an die _defer-verknüpfte Liste der aktuellen Goroutine.
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函数中newdefer wird zuerst eine herausnehmen _defer-Struktur aus sched und dem Deferpool des aktuellen p. Wenn der Deferpool nicht über _defer verfügt, initialisieren Sie ein neues _defer. _defer ist mit dem aktuellen g verknüpft, daher ist defer nur für das aktuelle g gültig. d.link = gp._defer
gp._defer = d //Verwenden Sie eine verknüpfte Liste, um alle Defers des aktuellen g zu verbinden
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
}deferreturn Nehmen Sie die _defer-verknüpfte Liste aus dem aktuellen g heraus und führen Sie sie aus um die _defer-Struktur freizugeben und die _defer-Struktur in den Deferpool des aktuellen p zu stellen.
Defer-Leistungsanalyse
Defer ist sehr nützlich für die Ressourcenfreigabe, Panikerfassung usw. während der Entwicklung. Es ist möglich, dass einige Entwickler die Auswirkungen der Verzögerung auf die Programmleistung und den Missbrauch von Verzögerungen in ihren Programmen nicht berücksichtigt haben.
Im Leistungstest kann festgestellt werden, dass die Verzögerung immer noch einen gewissen Einfluss auf die Leistung hat. Yuchens Go-Leistungsoptimierungstipps 4/1, es gibt einige Tests zum zusätzlichen Overhead, der durch Defer-Anweisungen verursacht wird.
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()
}Testergebnisse:
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
}
Aus der vorherigen Quellcode-Analyse können wir wissen, dass defer zuerst deferproc aufruft, das Parameter kopiert, und deferreturn auch relevante Informationen extrahiert, um die Ausführung zu verzögern. Diese sind besser als der direkte Aufruf einer Anweisung ist teurer.
Die Leistung der Verzögerung ist nicht hoch. Wenn sie mehrmals in einer Funktion auftritt, beträgt der Leistungsverbrauch 20 ns*n. Lösung: Außer wenn eine Ausnahmeerfassung erforderlich ist, muss „Defer“ verwendet werden. Für andere Ressourcenrecyclingverzögerungen können Sie „goto“ verwenden, um nach der Beurteilung des Fehlers zum Codebereich für das Ressourcenrecycling zu springen. Bei Konkurrenzressourcen können Sie die Ressourcen sofort nach der Verwendung freigeben, sodass die Konkurrenzressourcen optimal genutzt werden können.
Für mehr Golang-bezogenes Wissen besuchen Sie bitte die
GolangTutorial-Kolumne!