golang sync.RWMutex

sync.RWMutex
package main

import (
    "fmt"
    "runtime"
    "sync"
)

func clickWithMutex(total *int, m *sync.RWMutex, ch chan int) {
    for i := 0; i < 1000; i++ {
        m.Lock()
        *total += 1
        m.Unlock()
        //这里是写 下面是读,外层还有线程的竞争
        if i == 500 {
            m.RLock()
            fmt.Println(*total)
            m.RUnlock()
        }
    }
    ch <- 1
}

func main() {

    runtime.GOMAXPROCS(4) //使用多个处理器,不然都是顺序执行。

    m := new(sync.RWMutex)
    count := 0

    ch := make(chan int, 10) //保证输出时count完了

    for i := 0; i < 10; i++ {
        go clickWithMutex(&count, m, ch)
    }

    for i := 0; i < 10; i++ {
        <-ch
    }

    fmt.Printf("count:%d\n", count)
}
时间: 2024-11-06 07:25:47

golang sync.RWMutex的相关文章

golang 中 sync.Mutex 和 sync.RWMutex

介绍 golang 中的 sync 包实现了两种锁: Mutex:互斥锁 RWMutex:读写锁,RWMutex 基于 Mutex 实现 Mutex(互斥锁) Mutex 为互斥锁,Lock() 加锁,Unlock() 解锁 在一个 goroutine 获得 Mutex 后,其他 goroutine 只能等到这个 goroutine 释放该 Mutex 使用 Lock() 加锁后,不能再继续对其加锁,直到利用 Unlock() 解锁后才能再加锁 在 Lock() 之前使用 Unlock() 会导

golang sync.WaitGroup

//阻塞,直到WaitGroup中的所以过程完成. import ( "fmt" "sync" ) func wgProcess(wg *sync.WaitGroup, id int) { fmt.Printf("process:%d is going!\n", id) //if id == 2 { // return //} wg.Done() } func main() { //var wg sync.WaitGroup wg := new(

golang sync.Pool包的使用和一些注意地方

package main; import ( "sync" "fmt" "net" "runtime" ) //sync.Pool是一个可以存或取的临时对象集合 //sync.Pool可以安全被多个线程同时使用,保证线程安全 //注意.注意.注意,sync.Pool中保存的任何项都可能随时不做通知的释放掉,所以不适合用于像socket长连接或数据库连接池. //sync.Pool主要用途是增加临时对象的重用率,减少GC负担.

golang sync.Once

package main import ( "fmt" "sync" "time" ) var counter int = 0 func main() { var once sync.Once onceBody := func() { time.Sleep(3e9) fmt.Println("Only once") } done := make(chan bool) for i := 0; i < 10; i++ { j

golang sync.Mutex

//go func 和主线程之间的关系是并行和竞争关系 package main import ( "fmt" "sync" "time" ) var l sync.Mutex var m *sync.Mutex func main() { m = new(sync.Mutex) go lock(1) time.Sleep(3 * time.Second) fmt.Printf("%s\n", "exit!"

golang sync.Mutex(2)

package main import ( "fmt" "sync" "time" ) type User struct { Name string Locker *sync.Mutex } func (u *User) SetName(wati *sync.WaitGroup, name string) { defer func() { fmt.Println("Unlock set name:", name) u.Lock

Golang sync.NewCond条件锁的用法

package main import ( "fmt" "sync" "time" ) func main() { c := sync.NewCond(&sync.Mutex{}) queue := make([]interface{}, 0, 10) removeFromQueue := func(delay time.Duration) { time.Sleep(delay) c.L.Lock() queue = queue[1:]

golang中的Mutex和RWMutex

????sync中有两种锁 Mutex和RWMutex,Mutex的读和写必须都进行排队,只能一个完成了在进行下一个,RWMutex读可以并行,写只能一个一个进行,当有读时,需要所有的读全部关闭后才能进行写操作,有写 时,需要等写操作完成了才能进行读操作(读并行,写单一).(sync中有一个map对象是线程安全的,默认的map不是线程安全的). Mutex 先看下面的代码: package main import ( "fmt" "sync" "time&

sync:与golang的并发息息相关的包

楔子 我们知道golang除了兼顾了开发速度和运行效率之外,最大的亮点就是在语言层面原生支持并发,也就是通过所谓的goroutine.不过既然是并发,那么就势必会面临很多问题.比如:资源竞争,多个goroutine同时访问一个资源会发生竞争从而产生意想不到的结果,那么这时候我们会通过加锁来解决:主goroutine不能先退出,这时候我们会等待子goroutine.还有单例模式,以及对象池等等.那么golang是如何实现的呢?就是通过下面我们要介绍的sync包. sync.Mutex sync.M