Go defer 原理和源碼剖析(推薦)

更新時(shí)間：2021年11月13日 10:12:26 作者：編程寶庫(kù)

這篇文章主要介紹了Go defer 原理和源碼剖析,需要的朋友可以參考下

1. 編譯器編譯 defer 過(guò)程

defer dosomething(x)

簡(jiǎn)單來(lái)說(shuō)，執(zhí)行 defer 語(yǔ)句，實(shí)際上是注冊(cè)了一個(gè)稍后執(zhí)行的函數(shù)，確定了函數(shù)名和參數(shù)，但不會(huì)立即調(diào)用，而是把調(diào)用過(guò)程推遲到當(dāng)前函數(shù) return 或者發(fā)生 panic 的時(shí)候。

我們先了解一下 defer 相關(guān)的數(shù)據(jù)結(jié)構(gòu)。

1) struct _defer 數(shù)據(jù)結(jié)構(gòu)

go 語(yǔ)言程序中每一次調(diào)用 defer 都生成一個(gè) _defer 結(jié)構(gòu)體。

type _defer struct {
    siz     int32 // 參數(shù)和返回值的內(nèi)存大小
    started boul
    heap    boul    // 區(qū)分該結(jié)構(gòu)是在棧上分配的，還是對(duì)上分配的
    sp        uintptr  // sp 計(jì)數(shù)器值，棧指針；
    pc        uintptr  // pc 計(jì)數(shù)器值，程序計(jì)數(shù)器；
    fn        *funcval // defer 傳入的函數(shù)地址，也就是延后執(zhí)行的函數(shù);
    _panic    *_panic  // panic that is running defer
    link      *_defer   // 鏈表
}

我們默認(rèn)使用了 go 1.13 版本的源代碼，其它版本類(lèi)似。

一個(gè)函數(shù)內(nèi)可以有多個(gè) defer 調(diào)用，所以自然需要一個(gè)數(shù)據(jù)結(jié)構(gòu)來(lái)組織這些 _defer 結(jié)構(gòu)體。_defer 按照對(duì)齊規(guī)則占用 48 字節(jié)的內(nèi)存。在 _defer 結(jié)構(gòu)體中的 link 字段，這個(gè)字段把所有的 _defer 串成一個(gè)鏈表，表頭是掛在 Goroutine 的 _defer 字段。

_defer 的鏈?zhǔn)浇Y(jié)構(gòu)如下：

_defer.siz 用于指定延遲函數(shù)的參數(shù)和返回值的空間，大小由 _defer.siz 指定，這塊內(nèi)存的值在 defer 關(guān)鍵字執(zhí)行的時(shí)候填充好。

defer 延遲函數(shù)的參數(shù)是預(yù)計(jì)算的，在棧上分配空間。每一個(gè) defer 調(diào)用在棧上分配的內(nèi)存布局如下圖所示：

其中 _defer 是一個(gè)指針，指向一個(gè) struct _defer 對(duì)象，它可能分配在棧上，也可能分配在堆上。

2) struct _defer 內(nèi)存分配

以下是一個(gè)使用 defer 的范例，文件名為 test_defer.go：

package main

func doDeferFunc(x int) {
    println(x)
}

func doSomething() int {
    var x = 1
    defer doDeferFunc(x)
    x += 2
    return x
}

func main() {
    x := doSomething()
    println(x)
}

編譯以上代碼，加上去除優(yōu)化和內(nèi)鏈選項(xiàng)：

go tool compile -N -l test_defer.go

導(dǎo)出匯編代碼：

go tool objdump test_defer.o

我們看下編譯成的二進(jìn)制代碼：

從匯編指令我們看到，編譯器在遇到 defer 關(guān)鍵字的時(shí)候，添加了一些運(yùn)行庫(kù)函數(shù)：deferprocStack和deferreturn。

go 1.13 正式版本的發(fā)布提升了 defer 的性能，號(hào)稱(chēng)針對(duì) defer 場(chǎng)景提升了 30% 的性能。

go 1.13 之前的版本 defer 語(yǔ)句會(huì)被編譯器翻譯成兩個(gè)過(guò)程：回調(diào)注冊(cè)函數(shù)過(guò)程：deferproc和deferreturn

。

go 1.13 帶來(lái)的 deferprocStack 函數(shù)，這個(gè)函數(shù)就是這個(gè) 30% 性能提升的核心手段。deferprocStack 和 deferproc 的目的都是注冊(cè)回調(diào)函數(shù)，但是不同的是 deferprocStatck 是在棧內(nèi)存上分配 struct _defer 結(jié)構(gòu)，而 deferproc 這個(gè)是需要去堆上分配結(jié)構(gòu)內(nèi)存的。而我們絕大部分的場(chǎng)景都是可以是在棧上分配的，所以自然整體性能就提升了。棧上分配內(nèi)存自然是比對(duì)上要快太多了，只需要改變 rsp 寄存器的值就可以進(jìn)行分配。

那么什么時(shí)候分配在棧上，什么時(shí)候分配在堆上呢？

在編譯器相關(guān)的文件（src/cmd/compile/internal/gc/ssa.go ）里，有個(gè)條件判斷：

func (s *state) stmt(n *Node) {
 
    case ODEFER:
        d := callDefer
        if n.Esc == EscNever {
            d = callDeferStack
        }
}

n.Esc 是 ast.Node 的逃逸分析的結(jié)果，那么什么時(shí)候 n.Esc 會(huì)被置成 EscNever 呢？

這個(gè)在逃逸分析的函數(shù) esc 里（src/cmd/compile/internal/gc/esc.go ）：

func (e *EscState) esc(n *Node, parent *Node) {

    case ODEFER:
        if e.loopdepth == 1 { // top level
            n.Esc = EscNever // force stack allocation of defer record (see ssa.go)
            break
        }
}

這里 e.loopdepth 等于 1的時(shí)候，才會(huì)設(shè)置成 EscNever ，e.loopdepth 字段是用于檢測(cè)嵌套循環(huán)作用域的，換句話(huà)說(shuō)，defer 如果在嵌套作用域的上下文中，那么就可能導(dǎo)致 struct _defer 分配在堆上，如下：

package main

func main() {
    for i := 0; i < 10; i++ {
        defer func() {
            _ = i
        }()
    }
}

編譯器生成的則是 deferproc ：

當(dāng) defer 外層出現(xiàn)顯式（for）或者隱式（goto）的時(shí)候，將會(huì)導(dǎo)致 struct _defer 結(jié)構(gòu)體分配在堆上，性能就會(huì)變差，這個(gè)編程的時(shí)候要注意。

編譯器就能決定 _defer 結(jié)構(gòu)體分配在棧上還是堆上，對(duì)應(yīng)函數(shù)分別是 deferprocStatck 和 deferproc 函數(shù)，這兩個(gè)函數(shù)都很簡(jiǎn)單，目的一致：分配出 struct _defer 的內(nèi)存結(jié)構(gòu)，把回調(diào)函數(shù)初始化進(jìn)去，掛到鏈表中。

3) deferprocStack 棧上分配

deferprocStack 函數(shù)做了哪些事情呢？

// 進(jìn)入這個(gè)函數(shù)之前，就已經(jīng)在棧上分配好了內(nèi)存結(jié)構(gòu)
func deferprocStack(d *_defer) {
    gp := getg()

    // siz 和 fn 在進(jìn)入這個(gè)函數(shù)之前已經(jīng)賦值
    d.started = false
    // 表明是棧的內(nèi)存
    d.heap = false
    // 獲取到 caller 函數(shù)的 rsp 寄存器值，并賦值到 _defer 結(jié)構(gòu) sp 字段中
    d.sp = getcallersp()
    // 獲取到 caller 函數(shù)的 rip 寄存器值，并賦值到 _defer 結(jié)構(gòu) pc 字段中
    // 根據(jù)函數(shù)調(diào)用的原理，我們就知道 caller 的壓棧的 pc (rip) 值就是 deferprocStack 的下一條指令
    d.pc = getcallerpc()

    // 把這個(gè) _defer 結(jié)構(gòu)作為一個(gè)節(jié)點(diǎn)，掛到 goroutine 的鏈表中
    *(*uintptr)(unsafe.Pointer(&d._panic)) = 0
    *(*uintptr)(unsafe.Pointer(&d.link)) = uintptr(unsafe.Pointer(gp._defer))
    *(*uintptr)(unsafe.Pointer(&gp._defer)) = uintptr(unsafe.Pointer(d))
    // 注意，特殊的返回，不會(huì)觸發(fā)延遲調(diào)用的函數(shù)
    return0()
}

小結(jié)：

由于是棧上分配內(nèi)存的，所以調(diào)用到 deferprocStack 之前，編譯器就已經(jīng)把 struct _defer 結(jié)構(gòu)的函數(shù)準(zhǔn)備好了；
_defer.heap 字段用來(lái)標(biāo)識(shí)這個(gè)結(jié)構(gòu)體分配在棧上；
保存上下文，把 caller 函數(shù)的 rsp，pc（rip）寄存器的值保存到 _defer 結(jié)構(gòu)體；
_defer 作為一個(gè)節(jié)點(diǎn)掛接到鏈表。注意：表頭是 goroutine 結(jié)構(gòu)的 _defer 字段，而在一個(gè)協(xié)程任務(wù)中大部分有多次函數(shù)調(diào)用的，所以這個(gè)鏈表會(huì)掛接一個(gè)調(diào)用棧上的 _defer 結(jié)構(gòu)，執(zhí)行的時(shí)候按照 rsp 來(lái)過(guò)濾區(qū)分；4) deferproc 堆上分配

堆上分配的函數(shù)為 deferproc ，簡(jiǎn)化邏輯如下：

func deferproc(siz int32, fn *funcval) {
  // arguments of fn fullow fn
    // 獲取 caller 函數(shù)的 rsp 寄存器值
    sp := getcallersp()
    argp := uintptr(unsafe.Pointer(&fn)) + unsafe.Sizeof(fn)
    // 獲取 caller 函數(shù)的 pc（rip） 寄存器值
    callerpc := getcallerpc()

    // 分配 struct _defer 內(nèi)存結(jié)構(gòu)
    d := newdefer(siz)
    if d._panic != nil {
        throw("deferproc: d.panic != nil after newdefer")
    }
    // _defer 結(jié)構(gòu)體初始化
    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))
    }
    // 注意，特殊的返回，不會(huì)觸發(fā)延遲調(diào)用的函數(shù)
    return0()
}

小結(jié)：

與棧上分配不同，struct _defer 結(jié)構(gòu)是在該函數(shù)里分配的，調(diào)用 newdefer 分配結(jié)構(gòu)體，newdefer 函數(shù)則是先去 poul 緩存池里看一眼，有就直接取用，沒(méi)有就調(diào)用 mallocgc 從堆上分配內(nèi)存；
deferproc 接受入?yún)?siz，fn ，這兩個(gè)參數(shù)分別標(biāo)識(shí)延遲函數(shù)的參數(shù)和返回值的內(nèi)存大小，延遲函數(shù)地址；
_defer.heap 字段用來(lái)標(biāo)識(shí)這個(gè)結(jié)構(gòu)體分配在堆上；
保存上下文，把 caller 函數(shù)的 rsp，pc（rip）寄存器的值保存到 _defer 結(jié)構(gòu)體；
_defer 作為一個(gè)節(jié)點(diǎn)掛接到鏈表；

5) 執(zhí)行 defer 函數(shù)鏈

編譯器遇到 defer 語(yǔ)句，會(huì)插入兩個(gè)函數(shù)：

分配函數(shù)：deferproc 或者 deferprocStack ；
執(zhí)行函數(shù)：deferreturn 。

包裹 defer 語(yǔ)句的函數(shù)退出的時(shí)候，由 deferreturn 負(fù)責(zé)執(zhí)行所有的延遲調(diào)用鏈。

func deferreturn(arg0 uintptr) {
    gp := getg()
    // 獲取到最前的 _defer 節(jié)點(diǎn)
    d := gp._defer
    // 函數(shù)遞歸終止條件（d 鏈表遍歷完成）
    if d == nil {
        return
    }
    // 獲取 caller 函數(shù)的 rsp 寄存器值
    sp := getcallersp()
    if d.sp != sp {
        // 如果 _defer.sp 和 caller 的 sp 值不一致，那么直接返回；
        // 因?yàn)?，就說(shuō)明這個(gè) _defer 結(jié)構(gòu)不是在該 caller 函數(shù)注冊(cè)的  
        return
    }

    switch d.siz {
    case 0:
        // Do nothing.
    case sys.PtrSize:
        *(*uintptr)(unsafe.Pointer(&arg0)) = *(*uintptr)(deferArgs(d))
    default:
        memmove(unsafe.Pointer(&arg0), deferArgs(d), uintptr(d.siz))
    }
    // 獲取到延遲回調(diào)函數(shù)地址
    fn := d.fn
    d.fn = nil
    // 把當(dāng)前 _defer 節(jié)點(diǎn)從鏈表中摘除
    gp._defer = d.link
    // 釋放 _defer 內(nèi)存（主要是堆上才會(huì)需要處理，棧上的隨著函數(shù)執(zhí)行完，棧收縮就回收了）
    freedefer(d)
    // 執(zhí)行延遲回調(diào)函數(shù)
    jmpdefer(fn, uintptr(unsafe.Pointer(&arg0)))
}

代碼說(shuō)明：

遍歷 defer 鏈表，一個(gè)個(gè)執(zhí)行，順序鏈表從前往后執(zhí)行，執(zhí)行一個(gè)摘除一個(gè)，直到鏈表為空；
jmpdefer 負(fù)責(zé)跳轉(zhuǎn)到延遲回調(diào)函數(shù)執(zhí)行指令，執(zhí)行結(jié)束之后，跳轉(zhuǎn)回 deferreturn 里執(zhí)行；
_defer.sp 的值可以用來(lái)判斷哪些是當(dāng)前 caller 函數(shù)注冊(cè)的，這樣就能保證只執(zhí)行自己函數(shù)注冊(cè)的延遲回調(diào)函數(shù)；

例如，a() -> b() -> c() ，a 調(diào)用 b，b 調(diào)用 c ，而 a，b，c 三個(gè)函數(shù)都有 defer 注冊(cè)延遲函數(shù)，那么自然是 c()函數(shù)返回的時(shí)候，執(zhí)行 c 的回調(diào)；

2. defer 傳遞參數(shù)

1) 預(yù)計(jì)算參數(shù)

在前面描述 _defer 數(shù)據(jù)結(jié)構(gòu)的時(shí)候說(shuō)到內(nèi)存結(jié)構(gòu)如下：

_defer 在棧上作為一個(gè) header，延遲回調(diào)函數(shù)（ defer ）的參數(shù)和返回值緊接著 _defer 放置，而這個(gè)參數(shù)值是在 defer 執(zhí)行的時(shí)候就設(shè)置好了，也就是預(yù)計(jì)算參數(shù)，而非等到執(zhí)行 defer 函數(shù)的時(shí)候才去獲取。

舉個(gè)例子，執(zhí)行 defer func(x, y) 的時(shí)候，x，y 這兩個(gè)實(shí)參是計(jì)算的出來(lái)的，Go 中的函數(shù)調(diào)用都是值傳遞。那么就會(huì)把 x，y 的值拷貝到 _defer 結(jié)構(gòu)體之后。再看個(gè)例子：

package main

func main() {
    var x = 1
    defer println(x)
    x += 2
    return
}

這個(gè)程序輸出是什么呢？是 1 ，還是 3 ？答案是：1 。defer 執(zhí)行的函數(shù)是 println ，println 參數(shù)是 x ，x 的值傳進(jìn)去的值則是在 defer 語(yǔ)句執(zhí)行的時(shí)候就確認(rèn)了的。

2) defer 的參數(shù)準(zhǔn)備

defer 延遲函數(shù)執(zhí)行的參數(shù)已經(jīng)保存在和 _defer 一起的連續(xù)內(nèi)存塊了。那么執(zhí)行 defer 函數(shù)的時(shí)候，參數(shù)是哪里來(lái)呢？當(dāng)然不是直接去 _defer 的地址找。因?yàn)檫@里是走的標(biāo)準(zhǔn)的函數(shù)調(diào)用。

在 Go 語(yǔ)言中，一個(gè)函數(shù)的參數(shù)由 caller 函數(shù)準(zhǔn)備好，比如說(shuō)，一個(gè) main() -> A(7) -> B(a) 形成類(lèi)似以下的棧幀：

所以，deferreturn 除了跳轉(zhuǎn)到 defer 函數(shù)指令，還需要做一個(gè)事情：把 defer 延遲回調(diào)函數(shù)需要的參數(shù)準(zhǔn)備好（空間和值）。那么就是如下代碼來(lái)做的視線(xiàn)：

func deferreturn(arg0 uintptr) {

    switch d.siz {
    case 0:
        // Do nothing.
    case sys.PtrSize:
        *(*uintptr)(unsafe.Pointer(&arg0)) = *(*uintptr)(deferArgs(d))
    default:
        memmove(unsafe.Pointer(&arg0), deferArgs(d), uintptr(d.siz))
    }

}

arg0 就是 caller 用來(lái)放置 defer 參數(shù)和返回值的棧地址。這段代碼的意思就是，把 _defer 預(yù)先的準(zhǔn)備好的參數(shù)，copy 到 caller 棧幀的某個(gè)地址（arg0）。

3. 執(zhí)行多條 defer

前面已經(jīng)詳細(xì)說(shuō)明了，_defer 是一個(gè)鏈表，表頭是 goroutine._defer 結(jié)構(gòu)。一個(gè)協(xié)程的函數(shù)注冊(cè)的是掛同一個(gè)鏈表，執(zhí)行的時(shí)候按照 rsp 來(lái)區(qū)分函數(shù)。并且，這個(gè)鏈表是把新元素插在表頭，而執(zhí)行的時(shí)候是從前往后執(zhí)行，所以這里導(dǎo)致了一個(gè) LIFO 的特性，也就是先注冊(cè)的 defer 函數(shù)后執(zhí)行。

4. defer 和 return 運(yùn)行順序

包含 defer 語(yǔ)句的函數(shù)返回時(shí)，先設(shè)置返回值還是先執(zhí)行 defer 函數(shù)？

1) 函數(shù)的調(diào)用過(guò)程

要理解這個(gè)過(guò)程，首先要知道函數(shù)調(diào)用的過(guò)程：

go 的一行函數(shù)調(diào)用語(yǔ)句其實(shí)非原子操作，對(duì)應(yīng)多行匯編指令，包括 1）參數(shù)設(shè)置，2） call 指令執(zhí)行；
其中 call 匯編指令的內(nèi)容也有兩個(gè)：返回地址壓棧（會(huì)導(dǎo)致 rsp 值往下增長(zhǎng)，rsp-0x8），callee 函數(shù)地址加載到 pc 寄存器；
go 的一行函數(shù)返回 return語(yǔ)句其實(shí)也非原子操作，對(duì)應(yīng)多行匯編指令，包括 1）返回值設(shè)置和 2）ret 指令執(zhí)行；
其中 ret 匯編指令的內(nèi)容是兩個(gè)，指令 pc 寄存器恢復(fù)為 rsp 棧頂保存的地址，rsp 往上縮減，rsp+0x8；
參數(shù)設(shè)置在 caller 函數(shù)里，返回值設(shè)置在 callee 函數(shù)里；
rsp, rbp 兩個(gè)寄存器是棧幀的最重要的兩個(gè)寄存器，這兩個(gè)值劃定了棧幀；

最重要的一點(diǎn)：Go 的 return 的語(yǔ)句調(diào)用是個(gè)復(fù)合操作，可以對(duì)應(yīng)一下兩個(gè)操作序列：

設(shè)置返回值
ret 指令跳轉(zhuǎn)到 caller 函數(shù)

2) return 之后是先返回值還是先執(zhí)行 defer 函數(shù)？

Golang 官方文檔有明確說(shuō)明：

That is, if the surrounding function returns through an explicit return statement, deferred functions are executedafter any result parameters are set by that return statementbutbefore the function returns to its caller.

也就是說(shuō)，defer 的函數(shù)鏈調(diào)用是在設(shè)置了返回值之后，但是在運(yùn)行指令上下文返回到 caller 函數(shù)之前。

所以含有 defer 注冊(cè)的函數(shù)，執(zhí)行 return 語(yǔ)句之后，對(duì)應(yīng)執(zhí)行三個(gè)操作序列：

設(shè)置返回值
執(zhí)行 defer 鏈表
ret 指令跳轉(zhuǎn)到 caller 函數(shù)

那么，根據(jù)這個(gè)原理我們來(lái)解析如下的行為：

func f1 () (r int) {
    t := 1
    defer func() {
        t = t + 5
    }()
    return t
}

func f2() (r int) {
    defer func(r int) {
        r = r + 5
    }(r)
    return 1
}

func f3() (r int) {
    defer func () {
        r = r + 5
    } ()
    return 1
}

這三個(gè)函數(shù)的返回值分別是多少？

答案：f1() -> 1，f2() -> 1，f3() -> 6 。

a) 函數(shù) f1 執(zhí)行 return t 語(yǔ)句之后：

設(shè)置返回值 r = t，這個(gè)時(shí)候局部變量 t 的值等于 1，所以 r = 1；
執(zhí)行 defer 函數(shù)，t = t+5 ，之后局部變量 t 的值為 6；
執(zhí)行匯編 ret 指令，跳轉(zhuǎn)到 caller 函數(shù)；

所以，f1() 的返回值是 1 ；

b) 函數(shù) f2 執(zhí)行 return 1 語(yǔ)句之后：

設(shè)置返回值 r = t，這個(gè)時(shí)候局部變量 t 的值等于 1，所以 r = 1；
執(zhí)行 defer 函數(shù)，t = t+5 ，之后局部變量 t 的值為 6；
執(zhí)行匯編 ret 指令，跳轉(zhuǎn)到 caller 函數(shù)；

所以，f2() 的返回值還是 1 ；

c) 函數(shù) f3 執(zhí)行 return 1 語(yǔ)句之后：

設(shè)置返回值 r = 1；
執(zhí)行 defer 函數(shù)，r = r+5 ，之后返回值變量 r 的值為 6（這是個(gè)閉包函數(shù)，注意和 f2 區(qū)分）；
執(zhí)行匯編 ret 指令，跳轉(zhuǎn)到 caller 函數(shù)；

所以，f1() 的返回值是 6 。

defer 關(guān)鍵字執(zhí)行對(duì)應(yīng) _defer 數(shù)據(jù)結(jié)構(gòu)，在 go1.1 - go1.12 期間一直是堆上分配，在 go1.13 之后優(yōu)化成棧上分配 _defer 結(jié)構(gòu)，性能提升明顯；
_defer 大部分場(chǎng)景是分配在棧上的，但是遇到循環(huán)嵌套的場(chǎng)景會(huì)分配到堆上，所以編程時(shí)要注意 defer 使用場(chǎng)景，否則可能出性能問(wèn)題；
_defer 對(duì)應(yīng)一個(gè)注冊(cè)的延遲回調(diào)函數(shù)（defer），defer 函數(shù)的參數(shù)和返回值緊跟 _defer，可以理解成 header，_defer 和函數(shù)參數(shù)，返回值所在內(nèi)存是一塊連續(xù)的空間，其中 _defer.siz 指明參數(shù)和返回值的所占空間大?。?/li>
同一個(gè)協(xié)程里 defer 注冊(cè)的函數(shù)，都掛在一個(gè)鏈表中，表頭為 goroutine._defer；

新元素插入在最前面，遍歷執(zhí)行的時(shí)候則是從前往后執(zhí)行。所以 defer 注冊(cè)函數(shù)具有 LIFO 的特性，也就是后注冊(cè)的先執(zhí)行；

不同的函數(shù)都在這個(gè)鏈表上，以 _defer.sp 區(qū)分；

defer 的參數(shù)是預(yù)計(jì)算的，也就是在 defer 關(guān)鍵字執(zhí)行的時(shí)候，參數(shù)就確認(rèn)，賦值在 _defer 的內(nèi)存塊后面。執(zhí)行的時(shí)候，copy 到棧幀對(duì)應(yīng)的位置上；

return 對(duì)應(yīng) 3 個(gè)動(dòng)作的復(fù)合操作：設(shè)置返回值、執(zhí)行 defer 函數(shù)鏈表、ret 指令跳轉(zhuǎn)。

參考：編程寶庫(kù) go 語(yǔ)言教程。

到此這篇關(guān)于Go defer 原理和源碼剖析的文章就介紹到這了,更多相關(guān)Go defer 原理內(nèi)容請(qǐng)搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！

您可能感興趣的文章: