golang并发----用带缓冲通道实现一个信号量

信号量是实现互斥锁(排外锁)常见的同步机制,限制对资源的访问,解决读写问题.

• 带缓冲通道的容量和要同步的资源容量相同
• 通道的长度(当前存放的元素个数)与当前资源被使用的数量相同
• 容量减去通道的长度就是未处理的资源个数(标准信号量的整数值)

type Empty interface {}
type semaphore chan Empty
// acquire n resources
func (s semaphore) P(n int) {
 e := new(Empty)
 for i := 0; i < n; i++ {
 s <- e
 }
}
// release n resources
func (s semaphore) V(n int) {
 for i:= 0; i < n; i++{
 <- s
 }
}
/* mutexes */
func (s semaphore) Lock() {
 s.P(1)
}
func (s semaphore) Unlock(){
 s.V(1)
}
/* signal-wait */
func (s semaphore) Wait(n int) {
 s.P(n)
}
func (s semaphore) Signal() {
 s.V(1)
}

锁定缓冲通道:将一个通道作为锁来使用

• 函数通过在channel上发送信息获取锁
• 函数继续读写等修改共享内存
• 通过读取channel中的数据释放锁
• 在该锁被释放之前 是一直被占用状态

func worker(id int, lock chan bool) {
 fmt.Printf("%d wants the lock.\n", id)
 // 谁先向channel发数据这个锁就归谁
 lock <- true
 fmt.Printf("%d has the lock.\n", id)
 time.Sleep(500 * time.Millisecond)
 fmt.Printf("%d is releasing the lock.\n", id)
 // 从该channel中读取数据意味着释放锁
 <-lock
}
func main() {
 lock := make(chan bool, 1)
 for i := 1; i < 7; i++ {
 // 将channel作为锁使用 多个goroutine使用同一个channel
 go worker(i, lock)
 }
 time.Sleep(10 * time.Second)
}

本文来自:简书

感谢作者:

查看原文:golang并发----用带缓冲通道实现一个信号量

• 编辑
• 预览