Golang - 并发编程
1. 并行和并发
- 并行：在同一时刻，有多条指令在多个CPU处理器上同时执行
- 2个队伍，2个窗口，要求硬件支持
- 并发：在同一时刻，只能有一条指令执行，但多个进程指令被快速地轮换执行
- 2个队伍，1个窗口，要求提升软件能力
2. go语言并发优势
- go从语言层面就支持了并发
- 简化了并发程序的编写
3. goroutine是什么
- 它是go并发设计的核心
- goroutine就是协程，它比线程更小，十几个goroutine在底层可能就是五六个线程
- go语言内部实现了goroutine的内存共享，执行goroutine只需极少的栈内存(大概是4~5KB)
4. 创建goroutine
-
只需要在语句前添加go关键字，就可以创建并发执行单元
package main
import (
"fmt"
"time"
)//测试协程
//循环打印内容
func newTask() {
i := 0
for {
i++
fmt.Printf("new goroutine:i=%d\n", i)
time.Sleep(1 * time.Second)
}
}//main()相当于是主协程
func main() {
//启动子协程
go newTask()
i := 0
for {
i++
fmt.Printf("main goroutine:i=%d\n", i)
time.Sleep(1 * time.Second)
}
} 开发⼈员无需了解任何执⾏细节，调度器会自动将其安排到合适的系统线程上执行
-
如果主协程退出了，其他任务还执行吗？不执行
package main import (
"fmt"
"time"
) //main()相当于是主协程
func main() {
//匿名子协程
go func() {
i := 0
for {
i++
fmt.Println("子协程 i=", i)
time.Sleep(1 * time.Second)
}
}()
i := 0
for {
i++
fmt.Println("主协程 i=", i)
time.Sleep(1 * time.Second)
//主协程第二次后退出
if i == 2 {
break
}
}
} -
程序没任何输出，也不报错
package main import (
"fmt"
"time"
) //main()相当于是主协程
func main() {
//匿名子协程
go func() {
i := 0
for {
i++
fmt.Println("子协程 i=", i)
time.Sleep(1 * time.Second)
}
}()
}
5. runtime包
-
runtime.Gosched()：用于让出CPU时间片，调度器重新安排任务调度，还是有几率分配到它的
package main import (
"fmt"
"runtime"
) func main() {
//匿名子协程
go func(s string) {
for i := 0; i < 2; i++ {
fmt.Println(s)
}
}("world")
//主协程
for i := 0; i < 2; i++ {
runtime.Gosched()
fmt.Println("hello")
}
} -
runtime.Goexit()：立即终止当前协程
package main import (
"fmt"
"time"
"runtime"
) func main() {
//匿名子协程
go func() {
defer fmt.Println("A.defer")
//匿名函数
func() {
defer fmt.Println("B.defer")
//此时只有defer执行
runtime.Goexit()
fmt.Println("B")
}()
fmt.Println("A")
}()
for {
time.Sleep(time.Second)
}
} -
runtime.GOMAXPROCS()：设置并行计算的CPU核数，返回之前的值
package main import (
"runtime"
"fmt"
) func main() {
n := runtime.GOMAXPROCS(3)
fmt.Println("n=%d\n",n)
//循环执行2个
for{
go fmt.Print(0)
fmt.Print(1)
}
}
6. channel是什么
- goroutine运行在相同的地址空间，因此访问共享内存必须做好同步，处理好线程安全问题
- goroutine奉行通过通信来共享内存，而不是共享内存来通信
- channel是一个引用类型，用于多个goroutine通讯，其内部实现了同步，确保并发安全
7. channel的基本使用
channel可以用内置make()函数创建
-
定义一个channel时，也需要定义发送到channel的值的类型
make(chan 类型) //无缓冲的通道
make(chan 类型, 容量) //有缓冲的通道 当 capacity= 0 时，channel 是无缓冲阻塞读写的，当capacity> 0 时，channel 有缓冲、是非阻塞的，直到写满 capacity个元素才阻塞写入
-
channel通过操作符<-来接收和发送数据，发送和接收数据语法：
channel <- value //发送value到channel
<-channel //接收通道数据，并丢弃
x := <-channel //通道取值并赋给x
x, ok := <-channel //ok是检查通道是否关闭或者是否为空 -
channel基本使用
package main import "fmt" func main() {
//创建存放int类型的通道
c := make(chan int)
//子协程
go func() {
defer fmt.Println("子协程结束")
fmt.Println("子协程正在运行...")
//将666发送到通道c
c <- 666
}()
//若已取出数据，下面再取会报错
//<-c
//主协程取数据
//从c中取数据
num := <-c
fmt.Println("num = ", num)
fmt.Println("主协程结束")
}
8. 无缓冲的channel
- 无缓冲的通道是指在接收前没有能力保存任何值的通道
- 无缓冲通道，有可能阻塞
发送者 -> (通道(有可能有数据阻塞)) -> 接受者
package main
import (
"fmt"
"time"
)
func main() {
//创建无缓冲通道
c := make(chan int, 0)
//长度和容量
fmt.Printf("len(c)=%d, cap(c)=%d\n", len(c), cap(c))
//子协程存数据
go func() {
defer fmt.Println("子协程结束")
//向通道添加数据
for i := 0; i < 3; i++ {
c <- i
fmt.Printf("子协程正在运行[%d]:len(c)=%d,cap(c)=%d\n", i, len(c), cap(c))
}
}()
time.Sleep(2 * time.Second)
//主协程取数据
for i := 0; i < 3; i++ {
num := <-c
fmt.Println("num=", num)
}
fmt.Println("主协程结束")
}
9. 有缓冲的channel
- 有缓冲的通道是一种在被接收前能存储一个或者多个值的通道
发送者 -> (通道(数据),(数据)(...)) -> 接受者
-
上面代码创建时修改容量即可
//创建有缓存的通道
c :=make(chan int, 3)
10. close()
-
可以通过内置的close()函数关闭channel
package main import "fmt" func main() {
//创建通道
c := make(chan int)
//子协程存数据
go func() {
for i := 0; i < 5; i++ {
c <- i
}
//子协程close
close(c)
}()
//主协程取数据
for {
if data, ok := <-c; ok {
fmt.Println(data)
} else {
break
}
}
fmt.Println("Finshed")
} -
也可以如下遍历
for data := range c{
fnt.Println(data)
}
11. 单方向的channel
默认情况下，通道是双向的，也就是，既可以往里面发送数据也可以接收数据
-
go可以定义单方向的通道，也就是只发送数据或者只接收数据，声明如下
var ch1 chan int //正常的
var ch2 chan<- float64 //单向的，只用于写float64的数据
var ch3 <-chan int //单向的，只用于读取int数据 可以将 channel 隐式转换为单向队列，只收或只发，不能将单向 channel 转换为普通channel
func main() {
//创建通道
c := make(chan int, 3)
//1. 将c准换为只写的通道
var send <- chan int =c
//2. 将c转为只读的通道
var recv <- chan int =c
//往send里面写数据
send < -1
//从recv读数据
<-recv
}
-
单方向的channel有什么用？模拟生产者和消费者
package main import "fmt" //生产者，只写
func producter(out chan<- int) {
//关闭资源
defer close(out)
for i := 0; i < 5; i++ {
out <- i
}
} //消费者，只读
func consumer(in <-chan int) {
for num := range in {
fmt.Println(num)
}
} func main() {
//创建通道
c := make(chan int)
//生产者运行，向管道c存数据
go producter(c)
//消费者运行
consumer(c)
fmt.Println("done")
}
12. 定时器
-
Timer：定时，时间到了响应一次
package main import (
"time"
"fmt"
) func main() {
//1.基本使用
//创建定时器
//2秒后，定时器会将一个时间类型值，保存向自己的c
//timer1 := time.NewTimer(2 * time.Second)
////打印当前时间
//t1 := time.Now()
//fmt.Printf("t1:%v\n", t1)
////从管道中取出C打印
//t2 := <-timer1.C
//fmt.Printf("t2:%v\n", t2) //2.Timer只响应一次
//timer2 := time.NewTimer(time.Second)
//for {
// <-timer2.C
// fmt.Println("时间到")
//} //3.通过Timer实现延时的功能
////(1)睡眠
//time.Sleep(2*time.Second)
//fmt.Println("2秒时间到")
////(2)通过定时器
//timer3 := time.NewTimer(2 * time.Second)
//<-timer3.C
//fmt.Println("2秒时间到")
////(3)After()
//<-time.After(2 * time.Second)
//fmt.Println("2秒时间到") //4.停止定时器
//timer4 := time.NewTimer(3 * time.Second)
////子协程
//go func() {
// <-timer4.C
// fmt.Println("定时器器时间到，可以打印了")
//}()
//stop := timer4.Stop()
//if stop {
// fmt.Println("timer4已关闭")
//} //5.重置定时器
timer5 := time.NewTimer(3 * time.Second)
//定时器改为1秒
timer5.Reset(1 * time.Second)
fmt.Println(time.Now())
fmt.Println(<-timer5.C) for {
}
} -
Ticker：响应多次
package main
import (
"time"
"fmt"
)func main() {
//创建定时器，间隔1秒
ticker := time.NewTicker(time.Second)i := 0
//子协程
go func() {
for {
<-ticker.C
fmt.Println(<-ticker.C)
i++
fmt.Println("i=", i)
//停止定时器
if i == 5 {
ticker.Stop()
}
}
}() //死循环
for { }}
13. select
go语言提供了select关键字，可以监听channel上的数据流动
-
语法与switch类似，区别是select要求每个case语句里必须是一个IO操作
select {
case <-chan1:
// 如果chan1成功读到数据，则进行该case处理语句
case chan2 <- 1:
// 如果成功向chan2写入数据，则进行该case处理语句
default:
// 如果上面都没有成功，则进入default处理流程
} package main import (
"fmt"
) func main() {
//创建数据通道
int_chan := make(chan int, 1)
string_chan := make(chan string, 1)
//创建2个子协程，写数据
go func() {
//time.Sleep(2 * time.Second)
int_chan <- 1
}()
go func() {
string_chan <- "hello"
}()
//如果都能匹配到，则随机选择一个去跑
select {
case value := <-int_chan:
fmt.Println("intValue:", value)
case value := <-string_chan:
fmt.Println("strValue:", value)
}
fmt.Println("finish")
}
14. 携程同步锁
go中channel实现了同步，确保并发安全，同时也提供了锁的操作方式
go中sync包提供了锁相关的支持
-
Mutex：以加锁方式解决并发安全问题
package main import (
"time"
"fmt"
"sync"
) //账户
type Account struct {
money int
flag sync.Mutex
} //模拟银行检测
func (a *Account)Check() {
time.Sleep(time.Second)
} //设置账户余额
func (a *Account)SetAccount(n int) {
a.money +=n
} //查询账户余额
func (a *Account)GetAccount() int{
return a.money
} //买东西1
func (a *Account)Buy1(n int){
a.flag.Lock()
if a.money>n{
//银行检测
a.Check()
a.money -=n
}
a.flag.Unlock()
} //买东西2
func (a *Account)Buy2(n int){
a.flag.Lock()
if a.money>n{
//银行检测
a.Check()
a.money -=n
}
a.flag.Unlock()
} func main() {
var account Account
//设置账户余额
account.SetAccount(10)
//2个子协程买东西
go account.Buy1(6)
go account.Buy2(5)
time.Sleep(2 * time.Second)
fmt.Println(account.GetAccount())
} sync.WaitGroup：用来等待一组子协程的结束，需要设置等待的个数，每个子协程结束后要调用Done()，最后在主协程中Wait()即可
-
引入
package main import (
"fmt"
) func main() {
//创建通道
ch := make(chan int)
//count表示活动的协程个数
count := 2
go func() {
fmt.Println("子协程1")
//子协程1执行完成，给通道发送信号
ch <-1
}()
go func() {
fmt.Println("子协程2")
ch <-1
}()
//time.Sleep(time.Second)
//从ch中不断读数据
for range ch{
count --
if count == 0{
close(ch)
}
}
} go提供了这种解决方案sync.WaitGroup
Add()：添加计数
Done()：操作结束时调用，计数减去1
Wait()：主函数调用，等待所有操作结束
未完待续...