Go 学习笔记11.互斥锁，读写锁，状态协程

小鱼儿 2023-05-21 12:53 12阅读 0赞

## 互斥锁 ##

> 互斥所 它由标准库sync.Mutex来表示 方法有 Lock和Unlock

package main
    
    import (
       "fmt"
       "time"
    )
    
    func printer(str string) { 
       for _, data := range str { 
    	   time.Sleep(time.Millisecond*100)
    	   fmt.Printf("%c", data)
       }
       fmt.Println()
    }
    
    func print1() { 
       printer("hello")
    }
    
    func print2() { 
       printer("world")
    }
    
    
    func main() { 
    
       go print1()
       print2()
       time.Sleep(time.Second *2 )
    
    }

输出结果为
    hwoelrllo
    d
    
    我们希望是
    hello
    world
    这时候可以使用互斥锁了

package main
    
    import (
       "fmt"
       "time"
       "sync"
    )
    
    // 创建互斥锁对象
    var mutex sync.Mutex
    
    func printer(str string) { 
        mutex.Lock() //上锁
        // defer mut.Unlock() 这样皆可以，再执行结束后解锁，就不需要额外解锁了
        for _, data := range str { 
    	   time.Sleep(time.Millisecond*100)
    	   fmt.Printf("%c", data)
       }
        fmt.Println()
        mutex.Unlock() // 解锁
    }
    
    func print1() { 
       printer("hello")
    }
    
    func print2() { 
       printer("world")
    }
    
    
    func main() { 
    
       go print1()
       print2()
       time.Sleep(time.Second *2 )
    
    }

## 读写锁 ##

> 上面的互斥所，资源同时只能有一个协程访问
> 
> 但是，当我们取读数据的时候，数据是不会变得，可以随意的访问
> 
> 只有修改，写操作的时候，才会出现问题，这样读写锁就出现了
> 
> var mutex sync.RWMutex

package main
    
    import (
        "sync"
        "math/rand"
        "time"
        "fmt"
    )
    
    var count int
    
    var mutex sync.RWMutex
    
    func write(n int) { 
       mutex.Lock()
       rand.Seed(time.Now().UnixNano())
       fmt.Printf("写 goroutine %d 正在写数据...\n", n)
       // time.Sleep(time.Second)
       num := rand.Intn(500)
       count = num
       fmt.Printf("写 goroutine %d 写数据结束，写入新值 %d\n", n, num)
       mutex.Unlock()
    
    }
    
    func read(n int) { 
       mutex.RLock()
       fmt.Printf("读 goroutine %d 正在读取数据...\n", n)
       //time.Sleep(time.Millisecond*500)
       num := count
       fmt.Printf("读 goroutine %d 读取数据结束，读到 %d\n", n, num)
       mutex.RUnlock()
    }
    
    func main() { 
       // 500个协程读
       for i := 0; i < 500; i++ { 
          go read(i + 1)
       }
       // 10个协程写
       for i := 0; i < 10; i++ { 
          go write(i + 1)
       }
       time.Sleep(time.Second*5)
    }

## go状态协程 ##

package main
    
    import (
        "fmt"
        "math/rand"
        "sync/atomic"
        "time"
    )
    
    
    // 创建 读 写 结构体
    type readOp struct { 
        key  int
        resp chan int
    }
    type writeOp struct { 
        key  int
        val  int
        resp chan bool
    }
    
    func main() { 
    
        // 累加次数
        var ops int64
    
        // 读写结构体定义
        reads := make(chan *readOp)
        writes := make(chan *writeOp)
    
     
        
        go func() { 
            // 协程里面定义map字典，协程内私有的
            var state = make(map[int]int)
            for { 
                select { 
                case read := <-reads:
                    // 接收到读操作，将state[key]返回
                    read.resp <- state[read.key]
                case write := <-writes:
                    // 接收到写操作，将数据写入到state中
                    state[write.key] = write.val
                    write.resp <- true
                }
            }
        }()
    
        // 读，100个协程
        for r := 0; r < 100; r++ { 
            go func() { 
                for { 
                    //创建读结构体对象
                    read := &readOp{ 
                        key:  rand.Intn(5),
                        resp: make(chan int)}
                    //请求读操作
                    reads <- read
                    // 等待返回
                    <-read.resp
                    // 累加1
                    atomic.AddInt64(&ops, 1)
                }
            }()
        }
    
        // 写 10个协程
        for w := 0; w < 10; w++ { 
            go func() { 
                for { 
                    // 创建写结构体对象
                    write := &writeOp{ 
                        key:  rand.Intn(5),
                        val:  rand.Intn(100),
                        resp: make(chan bool)}
                    // 请求写操作
                    writes <- write
                    // 等待返回
                    <-write.resp
                    // 累加1
                    atomic.AddInt64(&ops, 1)
                }
            }()
        }
    
        // 让 Go 协程们跑 1s。
        time.Sleep(time.Second)
    
        // 最后，获取并报告 `ops` 值。
        opsFinal := atomic.LoadInt64(&ops)
        fmt.Println("ops:", opsFinal)
    }