Golang如何實現不被復制的結構體

這篇文章主要介紹“Golang如何實現不被復制的結構體”的相關知識，小編通過實際案例向大家展示操作過程，操作方法簡單快捷，實用性強，希望這篇“Golang如何實現不被復制的結構體”文章能幫助大家解決問題。

不允許復制的結構體

sync包中的許多結構都是不允許拷貝的，比如sync.Cond,sync.WaitGroup,sync.Pool, 以及sync包中的各種鎖，因為它們自身存儲了一些狀態(比如等待者的數量)，如果你嘗試復制這些結構體:

var wg1 sync.WaitGroup
wg2 := wg1 // 將 wg1 復制一份，命名為 wg2
// ...

那么你將在你的 IDE 中看到一個醒目的警告:

assignment copies lock value to wg2: sync.WaitGroup contains sync.noCopy

IDE是如何實現這一點的呢？我們自己又能否利用這一機制來告訴別人，不要拷貝某個結構體呢？

（懶得看原理，只想知道怎么用，可以直接下劃至結論部分）

實現原理

大部分編輯器/IDE都會在你的代碼上運行go vet,vet是Go官方提供的靜態分析工具，我們剛剛得到的提示信息就是vet分析代碼后告訴我們的。vet的實現在Go源碼的cmd/vet中,里面注冊了很多不同類型的分析器，其中copylock這個分析器會檢查實現了Lock和Unlock方法的結構體是否被復制。

copylock Analyser在cmd/vet中注冊，具體實現代碼在golang.org/x/tools/go/analysis/passes/copylock/copylock.go中, 這里只摘抄部分核心代碼進行解釋:

var lockerType *types.Interface

func init() {
    //...
    methods := []*types.Func{
        types.NewFunc(token.NoPos, nil, "Lock", nullary),
        types.NewFunc(token.NoPos, nil, "Unlock", nullary),
    }
    // Locker 結構包括了 Lock 和 Unlock 兩個方法
    lockerType = types.NewInterface(methods, nil).Complete()
}

init函數中把包級別的全局變量lockerType進行了初始化，lockerType內包含了兩個方法: Lock和Unlock, 只有實現了這兩個方法的結構體才是copylock Analyzer要處理的對象。

// lockPath 省略了參數部分，只保留了最核心的邏輯，
// 用來檢測某個類型是否實現了Locker接口(Lock和Unlock方法)
func lockPath(...) typePath {
    // ...
    // 如果傳進來的指針類型實現了Locker接口, 就返回這個類型的信息
    if types.Implements(types.NewPointer(typ), lockerType) && !types.Implements(typ, lockerType) {
        return []string{typ.String()}
    }
    // ...
}

lockPath會檢測傳入的參數是否實現了Lock和Unlock方法，如果是則返回類型的信息。而vet會在AST上每個需要檢查的節點上調用lockPath函數(如賦值、函數調用等場景)。如果在這些會導致復制的場景中，發現了鎖結構體的復制，則會報告給用戶:

func run(pass *analysis.Pass) (interface{}, error) {
    // ...
    // 需要檢查的節點
    switch node := node.(type) {
    // range語句
    case *ast.RangeStmt:
        checkCopyLocksRange(pass, node)
    // 函數聲明
    case *ast.FuncDecl:
        checkCopyLocksFunc(pass, node.Name.Name, node.Recv, node.Type)
    // 函數字面量(匿名函數)
    case *ast.FuncLit:
        checkCopyLocksFunc(pass, "func", nil, node.Type)
    // 調用表達式（Foo(xxx)）
    case *ast.CallExpr:
        checkCopyLocksCallExpr(pass, node)
    // 賦值語句
    case *ast.AssignStmt:
        checkCopyLocksAssign(pass, node)
    // 通用聲明(import/const/type/var)
    case *ast.GenDecl:
        checkCopyLocksGenDecl(pass, node)
    // 復合常量({a,b,c})
    case *ast.CompositeLit:
        checkCopyLocksCompositeLit(pass, node)
    // return語句
    case *ast.ReturnStmt:
        checkCopyLocksReturnStmt(pass, node)
    // ...
}

// checkCopyLocksAssign 檢查賦值操作是否復制了一個鎖
func checkCopyLocksAssign(pass *analysis.Pass, as *ast.AssignStmt) {
    for i, x := range as.Rhs {
        // 如果等號右邊的結構體里有字段實現了Lock/Unlock的話,就輸出警告信息
        if path := lockPathRhs(pass, x); path != nil {
            pass.ReportRangef(x, "assignment copies lock value to %v: %v", analysisutil.Format(pass.Fset, as.Lhs[i]), path)
        }
    }
}

上面只列出了賦值操作的實現代碼，其它類型的檢查這里就不一一解釋了，感興趣的同學可以自行查看源碼。

結論

只要你的IDE會幫你運行go vet(目前主流的VSCode和GoLand都會自動幫你運行)，你就能通過這個機制來提醒他人，盡量避免復制結構體。

如果你的結構體也因為某些原因，不希望使用者復制，你也可以使用該機制來警告使用者:

定義一個實現了Lock和Unlock的結構體

type noCopy struct{}

func (*noCopy) Lock()   {}
func (*noCopy) Unlock() {}

將其放入你的結構體中:

// Foo 代表你不希望別人復制的結構體
type Foo struct {
    noCopy noCopy
    // ...
}

或直接讓你的結構體實現Lock和Unlock方法:

type Foo struct {
    // ...
}

func (*Foo) Lock()   {}
func (*Foo) Unlock() {}

這樣別人在嘗試復制Foo的時候，就會得到IDE的警告信息了。

關于“Golang如何實現不被復制的結構體”的內容就介紹到這里了，感謝大家的閱讀。如果想了解更多行業相關的知識，可以關注億速云行業資訊頻道，小編每天都會為大家更新不同的知識點。