go并发编程

1waitgroup

WaitGroup就是等待所有的goroutine全部执行完毕，add方式和Down方法要配套使用

package mainimport ("fmt""sync"
)func main()  {var wq sync.WaitGroupwq.Add(100) //监控多少个goroutine执行结束for i:= 0;i<100;i++ {//开启一个协程go func(i int) {defer wq.Done() //和add是一起使用的fmt.Println(i)}(i)}wq.Wait() //等待所有的goroutine结束
}

2通过锁来完成全局变量的原子性操作

开启两个gorountine对total进行相同此时的加减，但是这一段程序的运行结果每一次都不一样

资源竞争，加锁

package mainimport ("fmt""sync"
)var total int
var wg sync.WaitGroupfunc main() {wg.Add(2)go add()go sub()wg.Wait()fmt.Println(total)
}
func add() {defer wg.Done()for i := 0; i < 100000; i++ {total += 1}
}func sub() {defer wg.Done()for i := 0; i < 100000; i++ {total -= 1}
}

加锁之后代码成功运行

package mainimport ("fmt""sync"
)var total int
var wg sync.WaitGroup
var lock sync.Mutexfunc main() {wg.Add(2)go add()go sub()wg.Wait()fmt.Println(total)
}
func add() {defer wg.Done()for i := 0; i < 100000; i++ {lock.Lock()total += 1lock.Unlock()}
}func sub() {defer wg.Done()for i := 0; i < 100000; i++ {lock.Lock()total -= 1lock.Unlock()}
}

锁不能复制。

更加优雅的方式，使用golang的原子包

package mainimport ("fmt""sync""sync/atomic"
)var total int64
var wg sync.WaitGroup//var lock sync.Mutexfunc main() {wg.Add(2)go add()go sub()wg.Wait()fmt.Println(total)
}
func add() {defer wg.Done()for i := 0; i < 100000; i++ {atomic.AddInt64(&total, 1)  //原子性的操作}
}func sub() {defer wg.Done()for i := 0; i < 100000; i++ {atomic.AddInt64(&total,-1)}
}

lock相对atomic性能较差，lock基于操作系统调度

3读写锁

锁实际上是将并行的代码串行化了，使用lock肯定影响性能，即使是设计所，也应该尽量保证并行

4goroutine进行通讯

不要通过共享内存来通讯，而要通过通讯来实现内存共享

channel的基础用法

package mainimport "fmt"func main()  {// 名字  类型  存储类型var msg chan string //默认值未nilmsg = make(chan string ,1)  //channel的初始化的值如果是0的话，放值进去会阻塞，如果设为0就为无缓冲channelmsg <- "大大怪" //将右边的值放在channel中name := <- msg //将channel中的值取出来给namefmt.Println(name)}

无缓冲channel用法

package mainimport ("fmt""time"
)func main() {// 名字  类型  存储类型var msg chan string //默认值未nilmsg = make(chan string, 0) //channel的初始化的值如果是0的话，放值进去会阻塞，如果设为0就为无缓冲channelgo func(msg chan string) {name := <-msg //将channel中的值取出来给namefmt.Println(name)}(msg)msg <- "大大怪"  //将右边的值放在channel中time.Sleep(time.Second*10)}

waitgroup少了一个done容易出现deadlock

无缓冲的channel也容易出现deadlock

适用场景

无缓冲channel适用于通知B要第一时间知道A是否已经完成

有缓冲channel适用于生产者和消费者之间的通讯

go中channel的应用场景

• 消息传递，消息过滤
• 信号广播
• 事件订阅和广播
• 任务分发
• 结果汇总
• 并发控制
• 同步和异步

5.单项channel的使用

默认情况下，channel是双向的，但是我们经常一个channel作为参数进行传递，希望对象也是单向使用

package mainimport "fmt"func main() {//var ch1 chan int //双向的channel//var ch2 chan<- float64 //单项channel,只能写入float64的数据//var ch3 <-chan int //只能读取int类型的数据/*定义一个channel然后把它编程单向的,但是不能把单项的channel转成双向的channel*/c := make(chan int, 3)var send chan<- int = cvar read <-chan int = csend <- 1num := <- readfmt.Println(num)
}

模拟单项channel存取数据

package mainimport ("fmt""time"
)func producer(out chan<- int)  {for i:=0;i<10 ;i++  {out <- i*i}close(out)
}func consumer(in <-chan int)  {for num := range in {fmt.Println(num)}
}
func main() {/*内部会完成自动的类型转换*/c := make(chan int)go producer(c)go consumer(c)time.Sleep(10*time.Second)
}

6交替打印

这是一道经典题目，在Java中也有提到，交替打印这个序列

12ab34cd56ef78gh910ij1112kl1314mn1516op1718qr1920st2122uv2324wx2526yz2728

利用channel阻塞的特性来实现

package mainimport ("fmt""time"
)var number, letter = make(chan bool), make(chan bool)func printNum() {i := 1for {//等待另外一个goroutine进行通知<-number //从number进行取值的操作，如果没有值就阻塞fmt.Printf("%d%d", i, i+1)i += 2letter <- true}
}
func printLetter() {str := "abcdefghijklmnopqrstuvwxyz"i := 0for {<-letterif i>= len(str){return}fmt.Print(str[i : i+2])i += 2number <- true // 存入true到channel中}
}func main() {go printNum()go printLetter()number <- truetime.Sleep(10*time.Second)
}