基础

并发：电脑同时听歌，看小说，打游戏。cpu根据时间片进行划分，交替执行这三个程序。我们可以感觉是同时产生的。
并行：多个cpu（多核）上述动作同时执行
C语言：，实现并发过程使用的是多线程（C++的最小资源单元）
Golang：Golang中不是线程，而是Go程（goroutine），Go程是Golang原生支持的，每一个Go程占用的系统资源，远远小于线程，一个Go程大约需要4k到5k的内存资源，一个程序可以启动大量的Go程序。相同的资源下，线程启动几十个，那么Go程是可以启动成百上千个。Go程对于高并发，性能非常好
Golang启动Go程，只需要在函数前面加上关键字go即可
启动多个子Go程它们会竞争cpu资源

package main

import (
	"fmt"
	"time"
)

func main() {
	go func() {
		count := 1
		for {
			fmt.Println("======>我是子go程:", count)
			count++
			time.Sleep(time.Second)
		}
	}()

	count := 1
	for {
		fmt.Println("我是主go程:", count)
		count++
		time.Sleep(time.Second)
	}
}

return、exit、goexit区别

return：返回当前函数
exit：退出当前进程
goexit：提前退出当前go程

return

package main

import (
	"fmt"
	"time"
)

func main() {
	go func() {
		func(){
			fmt.Println("这是子go程的内部函数")
			return	// 只是返回当前函数，对于上一层的函数会继续执行
		}()
		fmt.Println("子go程结束")
	}()

	fmt.Println("这是主go程")
	time.Sleep(5 * time.Second)
	fmt.Println("over")
}

exit

package main

import (
	"fmt"
	"os"
	"time"
)

func main() {
	go func() {
		func(){
			fmt.Println("这是子go程的内部函数")
			os.Exit(-1)		// 退出进程
		}()
		fmt.Println("子go程结束")
	}()

	fmt.Println("这是主go程")
	time.Sleep(5 * time.Second)
	fmt.Println("over")
}

goexit

package main

import (
	"fmt"
	"runtime"
	"time"
)

func main() {
	go func() {
		func(){
			fmt.Println("这是子go程的内部函数")
			runtime.Goexit()	// 退出当前go程
		}()
		fmt.Println("子go程结束")
	}()

	fmt.Println("这是主go程")
	time.Sleep(5 * time.Second)
	fmt.Println("over")
}

多go程通信（channel）

但涉及到多go程时，c语言使用互斥量，上锁来保持资源同步，避免资源竞争问题
Golang也支持这种方式，但是go语言更好的解决方案是使用管道、通道
使用通道不需要我们去进行加解锁
A往通道里面写数据，B从管道里面读数据，Golang自动帮我们做好了数据同步

package main

import "fmt"

func main() {
	// 使用一个管道，一定要make，同map一样，否则为nil
	// 此时是无缓冲的管道，会写一个读一个，也称无缓存管道
	numChan := make(chan int)
	// 如果创建的管道给入容量，那么将会批量写入，也称有缓冲通道
	// numChan := make(chan int， 10)

	// 创建两个go程，父母写数据，儿子读数据。
	// 这是go程“儿子”，从管道中读取数据
	go func() {
		for i := 0; i < 50; i++ {
			data := <-numChan
			fmt.Println("<----这是go程“儿子”，读取数据:", data)
		}
	}()

	go func() {
		for i := 0; i < 20; i++ {
			// 这是go程“妈妈”，写入20个数据
			numChan <- i
			fmt.Println("---->这是go“妈妈”，写入数据:", i)
		}
	}()

	for i := 20; i < 50; i++ {
		// 这是go程“爸爸”，写入30个数据
		numChan <- i
		fmt.Println("---->这是go程”爸爸“，写入数据:", i)
	}
}

管道的注意点

管道nil

如果管道没有使用make分配空间，那么管道默认为nil，读取写入都会阻塞

package main

import "fmt"

func main() {
	var numChan chan int
	numChan <- 1
	fmt.Println("numChan", <- numChan)
}

管道死锁

当管道读写次数不一致的时候，如果阻塞在主go程，那么程序会崩溃，如果阻塞在子go程，那么会出现内存泄露

package main

import "fmt"

func main() {
	numChan := make(chan int, 10)
	
	// 写入数据到管道
	go func() {
		for i := 0; i < 50; i++ {
			numChan <- i
			fmt.Println("写入数据:", i)
		}
	}()
    
    // 读，当主程序被管道阻塞时，那么程序将锁死崩溃
	for i := 0; i < 60; i++ {
		fmt.Println("numChan:", <-numChan)
	}
}

for range遍历管道

for range是不知道管道是否写完，所以会一直等待，一直等待就会导致死锁

package main

import "fmt"

func main() {
	numChan := make(chan int, 10)
	go func() {
		for i := 0; i < 50; i++ {
			numChan <- i
			fmt.Println("写入数据:", i)
		}
	}()

	// 遍历管道时，只返回值，不返回坐标
	for val := range numChan{
		fmt.Println("读取数据:",val)
	}
}

在写入端，将管道关闭，for range遍历关闭管道(nil)时，会退出就不会导致死锁

package main

import "fmt"

func main() {
	numChan := make(chan int, 10)
	go func() {
		for i := 0; i < 50; i++ {
			numChan <- i
			fmt.Println("写入数据:", i)
		}
		// 手动关闭管道
		close(numChan)
	}()

	for val := range numChan{
		fmt.Println("读取数据:",val)
	}
}

判断管道是否已经关闭

我们如何知道一个管道的状态，如果已经关闭了，读没事，会返回零值，如果再写入的话会有崩溃风险
有没有类似于map读取的那种方式val, ok := numMap[0]的这种ok-idiom方式知道呢

package main

import "fmt"

func main() {
	numChan := make(chan int, 10)
	go func() {
		for i := 0; i < 10; i++ {
			numChan <- i
			fmt.Println("写入数据:", i)
		}
		// 手动关闭管道
		close(numChan)
	}()

	for {
		val, ok := <-numChan
		if ok {
			fmt.Println("读取数据:", val)
		} else {
			fmt.Println("管道已经关闭")
			break
		}
	}
}

单向通道

numChan := make(chan int, 10)双向通道，既可以读，也可以写
单向通道：这样的设计是为了明确语义，一般用于函数参数
- 单向读通道：var numChanReadOnly <- chan int
- 单向写通道：var numChanWriteOnly chan <- int
双向管道可以赋值给同类型的单向管道，但单向通道不能赋值给同类型的双向通道

package main

import (
	"fmt"
	"time"
)

func main() {
	// 生产者消费者模型（、producer）
	// C语言：数组+锁，thread1:写，thread2:读
	// Golang：goroutine + channel

	// 在主函数中创建一个双向通道
	numChan := make(chan int, 10)
	// 双向管道可以赋值给同类型的单向管道

	// 将numChan，传递给producer，负责生产
	go producer(numChan)

	// 将numChan，传递给consumer 负责消费
	go consumer(numChan)

	time.Sleep(5 * time.Second)

}

// 生产者，提供一个只写通道
func producer(write chan<- int) {
	for i := 0; i < 50; i++ {
		write <- i
		// 写管道中不允许读操作
		// data <- write
		fmt.Println("向管道中写入数据:", i)
	}
}

// 消费者，提供一个只读通道
func consumer(read <-chan int) {
	// 读通道不允许写入操作
	// read <- 12
	for val := range read {
		fmt.Println("向管道中写入数据:", val)
	}
}

管道监听（select）

当程序中有多个channel协同工作，chan1,chan2，某一时刻，chan1或chan2触发了，程序要做出处理，使用select来监听多个通道，当管道被触发时（写入数据、读取数据、关闭管道），select语法与switch case很像，但是所有的分支条件必须是管道io

package main

import (
	"fmt"
	"time"
)

func main() {
	// 启动一个go程，负责监听两个channel

	chan1 := make(chan int)
	chan2 := make(chan int)

	go func() {
		for {
			select {
			case val := <-chan1:
				fmt.Println("从chan1读取数据成功：", val)
			case val2 := <-chan2:
				fmt.Println("从chan2读取数据成功：", val2)
			}
		}
	}()

	go func() {
		for i := 0; i < 10; i++ {
			chan1 <- i
			time.Sleep(time.Second)
		}
	}()

	go func() {
		for i := 0; i < 10; i++ {
			chan2 <- i
			time.Sleep(time.Second)
		}
	}()

	for{

	}
}

管道总结

当管道写满了，写阻塞
当缓冲区读完了，读阻塞
如果管道没有使用make分配空间，管道默认nil
- 从nil管道读取/写入数据，都会阻塞（不会崩溃）
从一个已经close的管道读取/写入数据时，会返回零值（不会崩溃）
一个管道，如果重复关闭，程序会崩溃
关闭管道的动作，一定要在写管道的操作方执行，不应该放在读端，否则继续写会崩溃
读写通道次数一定要对等
- 否则在多个go程中，会出现资源泄露
- 在主go程中，会出现程序崩溃（deadlock）