前文不是写了一个学习流程总览么，第二阶段有一个并发与并行
1.并发模型、goroutine和channel：
2.Go语言采用了一种称为"并发模型"的方式来处理并发任务。并发模型中的关键要素是goroutine和channel。 3.goroutine是轻量级的执行单元，类似于线程，但比线程更轻量级且由Go运行时环境直接管理。你可以通过在函数前添加go关键字来创建一个新的goroutine。 4.channel用于在不同的goroutine之间传递数据和进行同步操作。它是一种类型安全的通信机制，类似于管道，用于发送和接收值。
5.Goroutine管理和与线程、协程的区别：
6.Goroutine由Go运行时环境调度，而不是由操作系统内核调度，因此创建和切换goroutine的开销远远小于线程。 7.与传统的线程和协程相比，goroutine的开销非常小，可以创建成千上万个goroutine，而不会导致系统资源耗尽。 8.Goroutine之间的切换由Go运行时环境自行决定，开发人员无需显式控制或关注。
9.Channel的概念和用法：
10.Channel是用来在goroutine之间进行通信和同步的机制。 11.通过make函数创建一个channel，可以指定channel传递的值的类型。 12.使用<-操作符来发送和接收数据。发送数据使用channel <- value语法，接收数据使用value := <- channel语法。 13.Channel的发送和接收操作都是阻塞的，当goroutine在channel上发送或接收数据时，它们会暂停执行直到操作完成。
14.互斥锁（mutex）保证共享资源的安全访问：
15.在多个goroutine访问共享资源时，需要确保同时只有一个goroutine可以修改共享资源，以避免数据竞争和不确定的结果。 16.互斥锁（mutex）是一种同步原语，用于保护临界区，只允许一个goroutine进入临界区执行。 17.使用sync包中的Mutex类型来创建互斥锁。通过调用Lock()和Unlock()方法来获取和释放锁。
18.并行计算和性能优化：
19.并行计算是指将任务划分为多个子任务，并同时执行这些子任务以提高程序的性能。 20.Go语言提供了并行化的支持，可以使用go关键字创建多个goroutine来并行执行任务。 21.在并行计算中，需要注意数据的共享和同步问题，通过合理使用互斥锁或其他同步机制来保证共享资源的安全访问。 22.使用并行化技术可以充分利用多核处理器的性能优势，加快程序的执行速度。
当涉及到并发与并行时，Go语言提供了许多强大的工具和技术，首要的是goroutine和channel。
1.Goroutine：Goroutine是Go语言中的轻量级执行单元，类似于线程，但占用的资源更少。Goroutine是由Go运行时环境（Goroutine Scheduler）进行管理和调度的。与传统的线程相比，创建一个新的goroutine所需的开销很小，可以轻松创建成千上万个goroutine，而不会导致系统资源耗尽。
通过使用关键字go，可以在Go语言中创建一个新的goroutine。例如，下面的代码展示了如何创建一个简单的goroutine：
func main() { go performTask() // 创建并启动一个新的goroutine // 执行其他任务... }
func performTask() { // 执行任务... }
在上面的示例中，performTask()函数会在一个新的goroutine中并发执行，而main()函数会继续执行其他任务，而不必等待performTask()的完成。这样，你可以同时执行多个任务，从而提高程序的并发性能。
2.Channel：Channel是用于在不同的goroutine之间进行通信和同步的机制。它提供了一种安全、可靠的方式来传递数据。通过使用channel，你可以在goroutine之间传递数据，并控制它们之间的同步。
在Go语言中，通过使用make()函数来创建一个channel。可以指定channel传递的值的类型。例如，下面的代码展示了如何创建一个传递整数的channel： ch := make(chan int)
使用channel进行数据的发送和接收是通过<-操作符进行的。发送操作使用channel <- value语法，其中value是要发送的值。接收操作使用value := <- channel语法，其中value是接收到的值。这两个操作都是阻塞的，意味着发送操作会等待接收方接收数据，接收操作会等待发送方发送数据。 下面是一个示例，演示了如何在两个goroutine之间进行数据的传递：
func main() { ch := make(chan string) go sendData(ch) receiveData(ch) }
func sendData(ch chan string) { ch <- "Hello" ch <- "World" close(ch) }
func receiveData(ch chan string) { for msg := range ch { fmt.Println(msg) } }
在上面的示例中，sendData()函数会将字符串发送到channel中，而receiveData()函数会从channel中接收并打印接收到的字符串。通过使用channel，在两个goroutine之间实现了数据的传递和同步。
3.互斥锁（mutex）：在多个goroutine访问共享资源时，需要确保对共享资源的访问是安全的，以避免数据竞争和不确定的结果。互斥锁是一种常用的同步原语，用于保护临界区，只允许一个goroutine进入临界区执行。
在Go语言中，可以使用sync包中的Mutex类型来创建互斥锁。通过调用Lock()和Unlock()方法，可以获取和释放锁。例如，下面的代码展示了如何使用互斥锁来保护临界区：
import "sync"
var mutex sync.Mutex
func main() { // 启动多个goroutine并发执行 go incrementCounter() go incrementCounter() go incrementCounter()
// 等待所有goroutine完成 time.Sleep(time.Second) // 输出结果 fmt.Println(counter)}
var counter int
func incrementCounter() { mutex.Lock() // 获取互斥锁 counter++ mutex.Unlock() // 释放互斥锁 }
在上面的示例中，incrementCounter()函数会并发执行，它会使用互斥锁来保护对counter变量的访问，确保每次只有一个goroutine可以修改counter的值。
4.并行计算和性能优化：Go语言提供了并行化的支持，可以使用并行化技术来利用多核处理器的性能优势，加快程序的执行速度。
通过使用goroutine并发执行多个任务，并且合理地处理数据的共享和同步，可以实现并行计算。在并行计算中，将任务划分为多个子任务，每个子任务由一个goroutine独立执行，从而减少了任务的执行时间。 一种常见的并行化技术是使用for循环和goroutine的组合。例如，下面的代码展示了如何使用并行化技术来计算一系列数字的平方和：
var wg sync.WaitGroup
func main() { numbers := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10} result := make(chan int)
for _, num := range numbers { wg.Add(1) go square(num, result) } go func() { wg.Wait() close(result) }() sum := 0 for res := range result { sum += res } fmt.Println("Sum of squares:", sum)}
func square(num int, result chan<- int) { defer wg.Done() result <- num * num }
在上面的示例中，我们使用了一个goroutine池来计算每个数字的平方，每个goroutine独立计算一个数字的平方，并将结果发送到result channel中。最后，主goroutine从result channel中接收结果，并计算平方和。 这些是Go语言并发与并行的关键概念和技术。通过理解和掌握这些概念，并且通过实践应用它们，你可以充分利用Go语言强大的并发和并行能力，编写高效、并行化的程序。
