package main
/**
并发concurrency
很多人都是冲着 Go 大肆宣扬的高并发而忍不住跃跃欲试，但其实从
源码的解析来看，goroutine 只是由官方实现的超级“线程池”而已。
不过话说回来，每个实例 4-5KB 的栈内存占用和由于实现机制而大幅
减少的创建和销毁开销，是制造 Go 号称的高并发的根本原因。另外，
goroutine 的简单易用，也在语言层面上给予了开发者巨大的便利。
并发不是并行：
并发切换时间片，单核是没有并行的，只有一个线程，在并行则是直接利用
多核实现多线程的运行，多核是并行，有多个线程，但 Go 可以设置使用核数，以发挥多核计算机
的能力。
高并发：因为创建销毁的很快，每一个占内存很小，
Goroutine 奉行通过通信来共享内存，而不是共享内存来通信。
*/
import (
"fmt"
"runtime"
"time"
)
func main1() {
go GO() //这就是一个Goroutine，运行了一个Goroutine，
time.Sleep(2 * time.Second) //暂停2秒钟，不暂停是不会输出的GOGOGO的，
}
func GO() {
fmt.Println("GOGOGO")
}
func main2() {
c := make(chan bool) //创建一个channel
go func() { //go后面接一个匿名函数
fmt.Println("GGGGGOOOOOO")
c <- true //channel中存入true或false随便，
}()
<-c //从channel中取出来，go启动一个Goroutine之后main函数就执行到<-c并且阻塞了，因为他在等着从
//channel中取出东西来，只有c <- true执行了，放入东西到channel了，main就可以取出东西来了，
//通知main函数，他那里执行完毕了，main就继续执行完了
}
func main3() {
c := make(chan bool)
go func() {
fmt.Println("GGGGGOOOOOO")
c <- true //执行打印v,执行fmt.Println(v)，
close(c) //关闭不再迭代，不关闭则一直打印死锁了
}()
for v := range c { //迭代channel的时候，一直在等待有值进去，才可以取出来，在打印出来，
fmt.Println(v)
}
/*
GGGGGOOOOOO
true
*/
}
func main() {
runtime.GOMAXPROCS(runtime.NumCPU()) //返回当前cpu的核数，并利用多核操作Goroutine(Goroutine是线程池)
c := make(chan bool)
for i := 0; i < 10; i++ {
go GO1(c, i) //启动9个goroutine
}
<-c //告诉main函数可以退出了
}
func GO1(c chan bool, index int) {
a := 1
for i := 0; i < 100000000; i++ {
a += 1
}
fmt.Println(index, a)
if index == 9 { //启动第九个goroutine的时候就可以告诉main函数可以退出了,
//多核的时候index=9不一定是最后执行的，所以不一定会执行9遍，有可能执行一遍就退出了,解决方法：缓存的channel
c <- true
}
}
package main
import (
"fmt"
"runtime"
)
//缓存的channel
func main() {
runtime.GOMAXPROCS(runtime.NumCPU())
c := make(chan bool, 10) //缓存的channel,缓存10个，
for i := 0; i < 10; i++ {
go GO1(c, i)
}
for i := 0; i < 10; i++ {
<-c //取10次，就知道goroutine执行完了，这样就保证了能够打印10 次
}
}
func GO1(c chan bool, index int) {
a := 1
for i := 0; i < 100000000; i++ {
a += 1
}
fmt.Println(index, a) //，这样就保证了能够打印10 次
c <- true //存10次
}
/*
9 100000001
5 100000001
0 100000001
8 100000001
7 100000001
4 100000001
1 100000001
2 100000001
6 100000001
3 100000001
*/
package main
import (
"fmt"
"runtime"
"sync" //有一个任务组，每完成一个任务就减一，等任务数为0的时候任务就完成了
)
//第二种解决方案：同步，通过同步包实现多个Goroutine 打印内容
func main() {
runtime.GOMAXPROCS(runtime.NumCPU())
wg := sync.WaitGroup{} //创建一个任务组
wg.Add(10) //添加10个任务
for i := 0; i < 10; i++ {
go GO1(&wg, i) //添加10个Goroutine
}
wg.Wait() //等待
}
func GO1(wg *sync.WaitGroup, index int) {
fmt.Println(index) //打印就是一次任务
wg.Done() //任务完成一次
}
/*
0 9 1 2 3 4 5 6 7 8
*/
