信号量是实现互斥锁(排外锁)常见的同步机制,限制对资源的访问,解决读写问题.
- 带缓冲通道的容量和要同步的资源容量相同
- 通道的长度(当前存放的元素个数)与当前资源被使用的数量相同
- 容量减去通道的长度就是未处理的资源个数(标准信号量的整数值)
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)
}
