网站首页 返回列表像“草根”一样，紧贴着地面，低调的存在，冬去春来，枯荣无恙。

如何理解Golang的 “must not be copied after first use”（源码解析）

2020-06-10 02:40:21 admin 619

## 前言

阅读Golang sync包时，总会看到一句话“must not be copied after first
use”，对此感到很好奇，查阅过程中发现这篇文章总结得挺到位的，因此转载，记录一下，因为我只是对于原理上面好奇，因此没有全文翻译过来，只挑选了一些自己感兴趣的地方用自己的话总结了一下，感兴趣的可以看看原文章：  
[What does “nocopy after first use” mean in golang and
how](https://links.jianshu.com/go?to=https%3A%2F%2Fmedium.com%2F%40bronzesword%2Fwhat-
does-nocopy-after-first-use-mean-in-golang-and-how-12396c31de47)

## 正文

> must not be copied after first use

初次使用后不能复制，sync包大多跟并发控制相关，出于安全考虑（避免指针的复制使得指针污染不安全，误操作而使程序崩溃）不能复制可以理解，但Golang是怎么样办到的呢，接下来就从源码层面看看

### 1\. 运行时检测，实例地址值传递

这个是在初次时候后记录变量地址，二次使用时比对变量地址，如果不同的话说明被复制了。  
首先，我们先来看一个比较明显的例子`strings.Builder`

type Builder struct {
        addr *Builder     // 关键所在，专门用来记录Builder实例的地址
        buf []byte
    }
    func (b *Builder) copyCheck() {
        if b.addr == nil {
            // 初始化，记录b实例的地址
            b.addr = (*Builder)(noescape(unsafe.Pointer(b)))
        } else if b.addr != b {
            panic("strings: illegal use of non-zero Builder copied by value")
        }
    }
    func (b *Builder) Write(p []byte) (int, error) {
        b.copyCheck()
        ...
    }
        
    // test case
    var a strings.Builder
    a.Write([]byte("testa"))
    var b = a
    b.Write([]byte("testb"))   // 这里是复制后使用，所以会诱发panic

很明显，`strings.Builder`通过一个指针来存储实例化后的实例地址，由于这个值是由内部赋值的，所以初次使用时为
`nil`，此时会存储地址，下次使用的时候会进行比对，不一致，说明被复制过了

接下来，我们回到sync包，来看看`sync.Cond`怎么处理

type Cond struct {
        noCopy  noCopy
        L       Locker
        notify  notifyList
        checker copyChecker
    }
    type copyChecker uintptr
    func (c *copyChecker) check() {
        if uintptr(*c) != uintptr(unsafe.Pointer(c)) &&
           !atomic.CompareAndSwapUintptr((*uintptr)(c), 0, uintptr(unsafe.Pointer(c))) &&
           uintptr(*c) != uintptr(unsafe.Pointer(c)) {
               panic("sync.Cond is copied")
        }
    }
    func (c *Cond) Wait() {
        c.checker.check()
        ...
    }

这里跟`strings.Builder`有点不一样，因为`sync.Cond`通过一个结构体`copyChecker`来进行判断处理，咱们来看看关键代码`check()`

if uintptr(*c) != uintptr(unsafe.Pointer(c)) &&
           !atomic.CompareAndSwapUintptr((*uintptr)(c), 0, uintptr(unsafe.Pointer(c))) &&
           uintptr(*c) != uintptr(unsafe.Pointer(c)) {
               panic("sync.Cond is copied")
        }

我们假设一下创建了一个cond，`cond := sync.NewCond(new(sync.Mutex))`，此时假设内存如 "cond内存示例假设图"
第一部分所示。接下来再调用`cond.Wait()`后会触发`check()`里面的

! atomic.CompareAndSwapUintptr((*uintptr)(c), 0, uintptr(unsafe.Pointer(c)))

由于此时checker值为0，因此会把checker的地址存储进去，那么此时cond.checker的值为cond.checker的地址（假设是0x04）

接下来当复制该变量`condB :=
cond`时，整块空间会被复制到一个新内存（假设此时checker地址为0x0A），这个时候如果再次调用`cond.Wait()`，那么一比对就会发现cond被复制了，于是乎就起到了复制检测的功能

cond内存示例假设图

### 2\. 静态代码检测，通过go vet

`-copylocks`是go
vet的一个flag，用来开启是否有不允许拷贝但被拷贝的代码检测，只需要定义一个结构体noCopy，然后嵌入到你不允许拷贝的结构体。如果你希望自己定义的一个结构体使用者无法拷贝，只能指针传递保证全局唯一的话，也可以使用这个方法处理

// noCopy may be embedded into structs which must not be copied
    // after the first use.
    type noCopy struct{}
    
    // Lock is a no-op used by -copylocks checker from `go vet`.
    func (*noCopy) Lock() {}
    func (*noCopy) UnLock() {}

实例代码：

// file: test.go
    package main
        
    type noCopy struct{}
        
    func (*noCopy) Lock()   {}
    func (*noCopy) Unlock() {}
        
    // sync.Pool
    type Pool struct {
        noCopy noCopy
        val    int
    }
        
    func main() {
        poolA := Pool{}
        poolB := poolA
        poolB.val = 1024
    }

然后通过命令`go vet -copylocks ./test.go`就可以检测到错误

$ go vet -copylocks ./test.go
    # command-line-arguments
    .\test.go:16:11: assignment copies lock value to poolB: command-line-arguments.Pool contains command-line-arguments.noCopy

回到sync包，我们也能看到一样的身影

type Cond struct {
        noCopy noCopy
        
        // L is held while observing or changing the condition
        L Locker
      
        notify  notifyList
        checker copyChecker
    }
    
    type Pool struct {
        noCopy noCopy
     
        local     unsafe.Pointer // local fixed-size per-P pool, actual type is [P]poolLocal
        localSize uintptr        // size of the local array
     
        victim     unsafe.Pointer // local from previous cycle
        victimSize uintptr        // size of victims array
     
        // New optionally specifies a function to generate
        // a value when Get would otherwise return nil.
        // It may not be changed concurrently with calls to Get.
        New func() interface{}
    }
     
    ...

转载文章，原文链接：如何理解Golang的 “must not be copied after first use”（源码解析）

关键字词golang 源码

分享到：

上一篇：? AI足球大数据爬虫分析(golang)

下一篇：golang-nsq系列(三)--nsqlookupd源码解析

如需留言，请登录，没有账号？请注册

0 条评论 0 人参与

网站首页 返回列表像“草根”一样，紧贴着地面，低调的存在，冬去春来，枯荣无恙。

如何理解Golang的 “must not be copied after first use”（源码解析）

admin 1年前

zhou 2年前

zhou 2年前

zhou 2年前

zhou 2年前

网站首页 返回列表 像“草根”一样，紧贴着地面，低调的存在，冬去春来，枯荣无恙。

如何理解Golang的 “must not be copied after first use”（源码解析）

admin 官方 1年前

zhou 2年前

zhou 2年前

zhou 2年前

zhou 2年前

网站首页返回列表像“草根”一样，紧贴着地面，低调的存在，冬去春来，枯荣无恙。

admin 1年前