网站建设模板怎么设计,阿里巴巴可以做网站吗,有没有专门建设网站的公司,江苏建设信息网站有时候打不开什么是锁呢#xff1f;就是某个协程#xff08;线程#xff09;在访问某个资源时先锁住#xff0c;防止其它协程的访问#xff0c;等访问完毕解锁后其他协程再来加锁进行访问。这和我们生活中加锁使用公共资源相似#xff0c;例如#xff1a;公共卫生间。
死锁
死锁是…什么是锁呢就是某个协程线程在访问某个资源时先锁住防止其它协程的访问等访问完毕解锁后其他协程再来加锁进行访问。这和我们生活中加锁使用公共资源相似例如公共卫生间。
死锁
死锁是指两个或两个以上的进程在执行过程中由于竞争资源或者由于彼此通信而造成的一种阻塞的现象若无外力作用它们都将无法推进下去。此时称系统处于死锁状态或系统产生了死锁 死锁 不是锁的一种是一种错误使用锁导致的现象。
1. 单go程自己死锁channel 应该在 至少 2 个以上的 go程中进行通信。否则死锁2. go程间channel访问顺序导致死锁使用channel一端读写 要保证另一端写读操作同时有机会执行。否则死锁。3. 多go程多channel 交叉死锁Ago程掌握M的同时尝试拿N Bgo程掌握N的同时尝试拿M。 4. 在go语言中尽量不要将 互斥锁、读写锁 与 channel 混用。 —— 隐性死锁。//单go程自己死锁ch : make(chan int) //channel
ch - 789 //写 这里写入就会阻塞
num : -ch //读
fmt.Println(num)//go程间channel访问顺序导致死锁ch : make(chan int)num : -ch //顺序不对阻塞了那么go就不执行了fmt.Println(num)go func() {ch - 789}()//多go程多channel 交叉死锁ch1 : make(chan int)
ch2 : make(chan int)go func() { // 子for {select {case num : -ch1:ch2 - num}}}()for {select {case num : - ch2:ch1 - num}}4. 在go语言中尽量不要将 互斥锁、读写锁 与 channel 混用。 —— 隐性死锁。
package mainimport (fmtmath/randsynctime
)var rwMutex sync.RWMutex //锁只有一把两个属性// 左写右读
// -chan int 读
func readGo(in -chan int, index int) {for {rwMutex.RLock() //以读模式加锁num : -infmt.Printf(----%dth 读 go程读出%d\n, index, num)time.Sleep(time.Second)rwMutex.RUnlock() //以读模式写锁}
}// chan- int 写
func writeGo(out chan- int, index int) {for {//生成随机数num : rand.Intn(1000)rwMutex.Lock() //以写模式加锁out - num //写进去fmt.Printf(%dth 写go程写入%d\n, index, num)time.Sleep(time.Millisecond * 300) // 放大实验现象rwMutex.Unlock() //解锁}
}func main() {// 播种随机数种子rand.Seed(time.Now().UnixNano())ch : make(chan int)for i : 0; i 5; i {go readGo(ch, i1)}for i : 0; i 5; i {go writeGo(ch, i1)}for true {}
}互斥锁
每个资源都对应于一个可称为 “互斥锁” 的标记这个标记用来保证在任意时刻只能有一个协程线程访问该资源。其它的协程只能等待。 互斥锁是传统并发编程对共享资源进行访问控制的主要手段它由标准库sync中的Mutex结构体类型表示。sync.Mutex类型只有两个公开的指针方法Lock和Unlock。Lock锁定当前的共享资源Unlock进行解锁。 在使用互斥锁时一定要注意对资源操作完成后一定要解锁否则会出现流程执行异常死锁等问题。通常借助defer。锁定后立即使用defer语句保证互斥锁及时解锁。如下所示 var mutex sync.Mutex // 定义互斥锁变量 mutex
func write(){ mutex.Lock( ) defer mutex.Unlock( ) }
互斥锁互斥量
A 、B go程 共同访问共享数据。 由于cpu调度随机需要对 共享数据访问顺序加以限定同步。
创建 mutex互斥锁访问共享数据之前加锁访问结束解锁。 在Ago程加锁期间B go程加锁会失败——阻塞。
直至 A go程 解说mutexB 从阻塞处。恢复执行。
package mainimport (fmttimesync
)// 使用channel 完成同步
/*var ch make(chan int)func printer(str string) {for _, ch : range str {fmt.Printf(%c, ch)time.Sleep(time.Millisecond * 300)}
}func person1() { // 先printer(hello)ch - 98
}func person2() { // 后- chprinter(world)
}func main() {go person1()go person2()for {;}
}
*/// 使用 “锁” 完成同步 —— 互斥锁
var mutex sync.Mutex // 创建一个互斥量 新建的互斥锁状态为 0. 未加锁。 锁只有一把。func printer(str string) {mutex.Lock() // 访问共享数据之前加锁for _, ch : range str {fmt.Printf(%c, ch)time.Sleep(time.Millisecond * 300)}mutex.Unlock() // 共享数据访问结束解锁
}func person1() { // 先printer(hello)
}func person2() { // 后printer(world)
}func main() {go person1()go person2()for {;}
}读写锁
互斥锁的本质是当一个goroutine访问的时候其他goroutine都不能访问。这样在资源同步避免竞争的同时也降低了程序的并发性能。程序由原来的并行执行变成了串行执行。 其实当我们对一个不会变化的数据只做“读”操作的话是不存在资源竞争的问题的。因为数据是不变的不管怎么读取多少goroutine同时读取都是可以的。 所以问题不是出在“读”上主要是修改也就是“写”。修改的数据要同步这样其他goroutine才可以感知到。所以真正的互斥应该是读取和修改、修改和修改之间读和读是没有互斥操作的必要的。 因此衍生出另外一种锁叫做读写锁。 读写锁可以让多个读操作并发同时读取但是对于写操作是完全互斥的。也就是说当一个goroutine进行写操作的时候其他goroutine既不能进行读操作也不能进行写操作。 GO中的读写锁由结构体类型sync.RWMutex表示。此类型的方法集合中包含两对方法 一组是对写操作的锁定和解锁简称“写锁定”和“写解锁” func (*RWMutex)Lock() func (*RWMutex)Unlock() 另一组表示对读操作的锁定和解锁简称为“读锁定”与“读解锁” func (*RWMutex)RLock() func (*RWMutex)RUlock() 读写锁 读时共享写时独占。写锁优先级比读锁高。
读写锁—数据同步
package mainimport (fmtmath/randsynctime
)var rwMutex sync.RWMutex //锁只有一把两个属性var value int //定义全局变量模拟共享数据// 左写右读
// -chan int 读
func readGo(index int) {for {rwMutex.RLock() //以读模式加锁 channel和读锁不能同时存在num : valuefmt.Printf(----%dth 读 go程读出%d\n, index, num)//time.Sleep(time.Second)rwMutex.RUnlock() //以读模式写锁}
}// chan- int 写
func writeGo(index int) {for {//生成随机数num : rand.Intn(1000)rwMutex.Lock() //以写模式加锁value num //写进去fmt.Printf(%dth 写go程写入%d\n, index, num)//time.Sleep(time.Millisecond * 300) // 放大实验现象rwMutex.Unlock() //解锁}
}func main() {// 播种随机数种子rand.Seed(time.Now().UnixNano())for i : 0; i 5; i {go readGo(i 1)}for i : 0; i 5; i {go writeGo(i 1)}for true {}
}读写锁—对应channel
package mainimport (fmtmath/randtime
)var value int //定义全局变量模拟共享数据// 左写右读
// -chan int 读
func readGo(ch -chan int, index int) {for {num : -ch //从channel中读取数据fmt.Printf(----%dth 读 go程读出%d\n, index, num)time.Sleep(time.Second)}
}// chan- int 写
func writeGo(ch chan- int, index int) {for {//生成随机数num : rand.Intn(1000)ch - num //写进去fmt.Printf(%dth 写go程写入%d\n, index, num)time.Sleep(time.Millisecond * 300) // 放大实验现象}
}func main() {// 播种随机数种子rand.Seed(time.Now().UnixNano())ch : make(chan int)for i : 0; i 5; i {go readGo(ch, i1)}for i : 0; i 5; i {go writeGo(ch, i1)}for true {}
}生产者消费者模型回顾
package mainimport (fmtmath/randtime
)// 左写
func producer(out chan- int, index int) {for i : 0; i 50; i {num : rand.Intn(800)fmt.Printf(生产者%dth生成:%d\n, index, num)out - num}close(out)
}// 右读
func consumer(in -chan int, index int) {for i : range in {fmt.Printf(-------消费者%dth消费:%d\n, index, i)//time.Sleep(time.Millisecond * 300)}
}func main() {product : make(chan int)rand.Seed(time.Now().UnixNano())for i : 0; i 5; i {go producer(product, i1)}for i : 0; i 5; i {go consumer(product, i1)}for {}
}在上面的代码中加了一个消费者同时在consumer方法中将数据取出来后又进行了一组运算。这时可能会出现一个协程从管道中取出数据参与加法运算但是还没有算完另外一个协程又从管道中取出一个数据赋值给了num变量。所以这样累加计算很有可能出现问题。当然按照前面的知识解决这个问题的方法很简单就是通过加锁的方式来解决。增加生产者也是一样的道理。
另外一个问题如果消费者比生产者多仓库中就会出现没有数据的情况。我们需要不断的通过循环来判断仓库队列中是否有数据这样会造成cpu的浪费。反之如果生产者比较多仓库很容易满满了就不能继续添加数据也需要循环判断仓库满这一事件同样也会造成CPU的浪费。
条件变量
条件变量的作用并不保证在同一时刻仅有一个协程线程访问某个共享的数据资源而是在对应的共享数据的状态发生变化时通知阻塞在某个条件上的协程线程。条件变量不是锁在并发中不能达到同步的目的因此条件变量总是与锁一块使用。 例如我们上面说的如果仓库队列满了我们可以使用条件变量让生产者对应的goroutine暂停阻塞但是当消费者消费了某个产品后仓库就不再满了应该唤醒发送通知给阻塞的生产者goroutine继续生产产品。 GO标准库中的sys.Cond类型代表了条件变量。条件变量要与锁互斥锁或者读写锁一起使用。成员变量L代表与条件变量搭配使用的锁。
type Cond struct {noCopy noCopy// L is held while observing or changing the conditionL Lockernotify notifyListchecker copyChecker
}对应的有3个常用方法WaitSignalBroadcast。 1)func (c *Cond) Wait() 该函数的作用可归纳为如下三点 a)阻塞等待条件变量满足 b)释放已掌握的互斥锁相当于cond.L.Unlock()。 注意两步为一个原子操作。 c)当被唤醒Wait()函数返回时解除阻塞并重新获取互斥锁。相当于cond.L.Lock() 2)func (c *Cond) Signal() 单发通知给一个正等待阻塞在该条件变量上的goroutine线程发送通知。 3)func (c *Cond) Broadcast() 广播通知给正在等待阻塞在该条件变量上的所有goroutine线程发送通知。
条件变量
本身不是锁 但经常与锁结合使用使用流程1. 创建 条件变量 var cond sync.Cond2. 指定条件变量用的 锁 cond.L new(sync.Mutex)3. cond.L.Lock() 给公共区加锁互斥量4. 判断是否到达 阻塞条件缓冲区满/空 —— for 循环判断for len(ch) cap(ch) { cond.Wait() —— 1) 阻塞 2) 解锁 3) 加锁5. 访问公共区 —— 读、写数据、打印 6. 解锁条件变量用的 锁 cond.L.Unlock()7. 唤醒阻塞在条件变量上的 对端。 signal() Broadcast()条件变量使用原理分析 条件变量生产者消费者–主要是串行
package mainimport (fmtmath/randsynctime
)var cond sync.Cond //定义全部条件变量// 左写
func producer(out chan- int, index int) {for {//先加锁cond.L.Lock()//判断缓冲区是否满if len(out) 5 {cond.Wait() //1 阻塞释放刚才的锁唤醒以后重新加锁}num : rand.Intn(800)out - numfmt.Printf(生产者%dth生成:%d\n, index, num)//返回公共区结束并且打印结束解锁cond.L.Unlock()//唤醒阻塞在条件变量上的消费者cond.Signal()time.Sleep(time.Millisecond * 200)}
}// 右读
func consumer(in -chan int, index int) {for {//先加锁cond.L.Lock()//判断缓冲器是否为空if len(in) 0 {cond.Wait()}num : -infmt.Printf(-------消费者%dth消费:%d\n, index, num)//访问公共区结束后解锁cond.L.Unlock()//唤醒 阻塞在条件变量上的生产者cond.Signal()time.Sleep(time.Millisecond * 200)}
}func main() {product : make(chan int, 6)rand.Seed(time.Now().UnixNano())//指定条件变量使用的锁cond.L new(sync.Mutex) //互斥锁初值0 未加锁状态for i : 0; i 5; i {go producer(product, i1)}for i : 0; i 5; i {go consumer(product, i1)}for {}
}判断wait使用for的原因分析—主要是并行
package mainimport (fmtmath/randsynctime
)var cond sync.Cond //定义全部条件变量// 左写
func producer(out chan- int, index int) {for {//先加锁cond.L.Lock()//判断缓冲区是否满for len(out) 5 { //如果有多个并行就要使用forcond.Wait() //1 阻塞释放刚才的锁唤醒以后重新加锁}num : rand.Intn(800)out - numfmt.Printf(生产者%dth生成:%d\n, index, num)//返回公共区结束并且打印结束解锁cond.L.Unlock()//唤醒阻塞在条件变量上的消费者cond.Signal()time.Sleep(time.Millisecond * 200)}
}// 右读
func consumer(in -chan int, index int) {for {//先加锁cond.L.Lock()//判断缓冲器是否为空for len(in) 0 {cond.Wait()}num : -infmt.Printf(-------消费者%dth消费:%d\n, index, num)//访问公共区结束后解锁cond.L.Unlock()//唤醒 阻塞在条件变量上的生产者cond.Signal()time.Sleep(time.Millisecond * 200)}
}func main() {product : make(chan int, 6)rand.Seed(time.Now().UnixNano())//指定条件变量使用的锁cond.L new(sync.Mutex) //互斥锁初值0 未加锁状态for i : 0; i 5; i {go producer(product, i1)}for i : 0; i 5; i {go consumer(product, i1)}for {}
}
