go并发编程基础-Toy模板网

这篇具有很好参考价值的文章主要介绍了go并发编程基础。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

go并发编程

1waitgroup

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

package main

import (
	"fmt"
	"sync"
)

func main()  {
	var wq sync.WaitGroup

	wq.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 main

import (
	"fmt"
	"sync"
)

var total int
var wg sync.WaitGroup

func 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 main

import (
	"fmt"
	"sync"
)

var total int
var wg sync.WaitGroup
var lock sync.Mutex

func 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 += 1
		lock.Unlock()
	}
}

func sub() {
	defer wg.Done()
	for i := 0; i < 100000; i++ {
		lock.Lock()
		total -= 1
		lock.Unlock()
	}
}

锁不能复制。

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

package main

import (
	"fmt"
	"sync"
	"sync/atomic"
)

var total int64
var wg sync.WaitGroup

//var lock sync.Mutex

func 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 main

import "fmt"

func main()  {
	// 名字  类型  存储类型
	var msg chan string //默认值未nil

	msg = make(chan string ,1)  //channel的初始化的值如果是0的话，放值进去会阻塞，如果设为0就为无缓冲channel

	msg <- "大大怪" //将右边的值放在channel中
	name := <- msg //将channel中的值取出来给name
	fmt.Println(name)

}

无缓冲channel用法

package main

import (
	"fmt"
	"time"
)

func main() {
	// 名字  类型  存储类型
	var msg chan string //默认值未nil

	msg = make(chan string, 0) //channel的初始化的值如果是0的话，放值进去会阻塞，如果设为0就为无缓冲channel
	go func(msg chan string) {
		name := <-msg //将channel中的值取出来给name
		fmt.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 main

import "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 = c
	var read <-chan int = c

	send <- 1
	num := <- read

	fmt.Println(num)
}

模拟单项channel存取数据

package main

import (
	"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阻塞的特性来实现文章来源地址https://www.toymoban.com/news/detail-674383.html

package main

import (
	"fmt"
	"time"
)

var number, letter = make(chan bool), make(chan bool)

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

func main() {
	go printNum()
	go printLetter()
	number <- true
	time.Sleep(10*time.Second)
}