go语言中的互斥 + defer

最新推荐文章于 2024-10-25 10:21:31 发布

Publish or Perish

最新推荐文章于 2024-10-25 10:21:31 发布

阅读量1.1k

点赞数 1

分类专栏： fabric项目学习笔记 go语言学习文章标签： mutex defer 互斥 go-defer go-mutex

本文链接：https://blog.youkuaiyun.com/code_segment/article/details/77481701

版权

go语言学习同时被 2 个专栏收录

24 篇文章

订阅专栏

fabric项目学习笔记

15 篇文章

订阅专栏

本文深入探讨了Golang中互斥锁的基本概念及其使用方法，并详细介绍了defer关键字的功能与应用场景，通过实例展示了如何利用这两种机制提高程序的并发性能。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

互斥

互斥是传统的并发程序对共享资源进行访问控制的主要手段。它由标准库代码包sync中的Mutex结构体类型代表。sync.Mutex类型（确切地说，是*sync.Mutex类型）只有两个公开方法——Lock和Unlock。顾名思义，前者被用于锁定当前的互斥量，而后者则被用来对当前的互斥量进行解锁。

包导入

import  "sync" //处理同步需求，导入包

定义
我们只需对它进行简单声明就可以正常使用了，就像这样：

var  mutex   = &sync.RWMutex{} //互斥定义

使用

mutex.Lock()  // 上锁
defer mutex.Unlock() // 解锁，在defer后指定的函数会在函数退出前调用。

比如在fabric v0.6 membersrvc/ca/ca.go中的代码片段：

// 通过证书hash值读取证书
func (ca *CA) readCertificateByHash(hash []byte) ([]byte, error) {
    caLogger.Debug("Reading certificate for hash " + string(hash) + ".")

    mutex.RLock()
    defer mutex.RUnlock()

    var raw []byte
    row := ca.db.QueryRow("SELECT cert FROM Certificates WHERE hash=?", hash)
    err := row.Scan(&raw) // scan将row中匹配的条目复制到raw指向的值。

    return raw, err
}

defer

在函数块中使用defer，相当于函数对应的栈空间，先进后出。函数结束后调用栈，进行defer操作。

golang的defer关键字，它可以在函数返回前执行一些操作，最常用的就是打开一个资源（例如一个文件、数据库连接等）时就用defer延迟关闭改资源，以免引起内存泄漏。

如下代码所示，我们一般写打开一个资源是这样操作的：

func ReadWrite() bool {
    file.Open("file")

    // to do something

    if failureX {
        file.Close()
        return false
    }

    if failureY {
        file.Close()
        return false
    }

    file.Close()
    return true
}

上面的代码有很多是重复的，go的defer有效解决了这个问题。使用它后，不但代码量减少了很多，而且程序变得更优雅：

func ReadWrite() bool {
    file.Open("file")
    defer file.Close()
    // to do something
    if failureX {
        return false
    }
    if failureY {
        return false
    }
    return true
}

示例代码：

代码地址：https://github.com/Agzs/goTest/blob/master/deferTest.go

package main

import "fmt"
import "time"

type User struct {
    username string
}

func (this *User) Close() {
    fmt.Println("\n", this.username, "Closed !!!")
}

func print(z int) {
    fmt.Println("print z = ", z)
}

func deferRet(x,y int) (int){
    z := 0
    defer print(z) // defer后面只能跟函数？？？
    z = x + y
    fmt.Println("deferRet z = ", z)
    return z + 50 
}

func main() {
    fmt.Println("print name:")
    u1 := &User{"jack"}
    defer u1.Close()
    u2 := &User{"lily"}
    defer u2.Close()

    time.Sleep(10 * time.Second)  // 实际上，线程Sleep的10秒，u1，和u2早就可以Close()了，但却需要依赖main()函数的结束，才能defer执行。

    fmt.Println("main Done !")

    // 函数中的defer
    res := deferRet(1,1)
    fmt.Println("main res = ", res)

    // 我们可以在官方的文档中看到defer的执行顺序是逆序的，也就是先进后出的顺序：
    // 打印结果是：4,3,2,1,0
    fmt.Printf("print i:")
    for i := 0; i < 5; i++ {
        defer fmt.Printf("%d ", i)
    }
    fmt.Println("")
}

运行程序$ go run deferTest.go ，运行结果：

print name: // 之后光标大概会闪烁10s，然后打印其他信息
main Done !
deferRet z =  2
print z =  0
main res =  52
print i:
4 3 2 1 0 
 lily Closed !!!

 jack Closed !!!

参考文章：
http://blog.youkuaiyun.com/eclipser1987/article/details/12089271
http://www.jb51.net/article/57335.htm