Go 是一门天生支持高并发的编程语言，它通过 Goroutine 和 Channel 等特性使并发编程变得简单且高效。以下是一个简单的示例代码，展示了 Go 如何实现高并发能力：
package main
import (
"fmt"
"sync"
"time"
)
func worker(id int, wg *sync.WaitGroup) {
defer wg.Done()
fmt.Printf("Worker %d started\n", id)
time.Sleep(time.Second) // 模拟工作
fmt.Printf("Worker %d finished\n", id)
}
func main() {
const numWorkers = 5
var wg sync.WaitGroup
for i := 1; i <= numWorkers; i++ {
wg.Add(1)
go worker(i, &wg)
}
wg.Wait()
fmt.Println("All workers finished")
}
在上述示例中，我们创建了 5 个 Goroutine 来模拟并发的工作。每个 Goroutine 执行 worker 函数来模拟工作，并在完成后通知 WaitGroup。主程序等待所有的 Goroutine 完成后才会继续执行。
这个例子展示了 Go 是如何通过 Goroutine 来实现并发的。Goroutine 是 Go 语言并发模型的基础，它们非常轻量级，可以在单个操作系统线程中同时运行成千上万个 Goroutine，从而实现高并发的能力。
需要注意的是，Go 的并发模型与传统的基于线程的并发模型有所不同。Goroutine 是由 Go 运行时系统进行调度的，不需要开发人员显式地管理线程。此外，为了实现 Goroutine 之间的安全通信和同步，Go 引入了 Channel，它可以用于在 Goroutine 之间传递数据和控制信号。
在实际应用中，您可以使用 Goroutine 和 Channel 来实现更复杂的并发模式，如并发任务执行、并发数据处理等。
并发任务执行：
假设您有一些任务需要并发地执行，您可以使用 Goroutine 来同时执行这些任务，然后使用 Channel 来汇总结果。下面是一个示例，展示如何使用 Goroutine 和 Channel 并发执行任务并收集结果：
package main
import (
"fmt"
"sync"
"time"
)
func worker(id int, jobs <-chan int, results chan<- int) {
for job := range jobs {
fmt.Printf("Worker %d started job %d\n", id, job)
time.Sleep(time.Second) // 模拟任务执行
results <- job * 2 // 将结果发送到通道
fmt.Printf("Worker %d finished job %d\n", id, job)
}
}
func main() {
const numJobs = 10
const numWorkers = 3
jobs := make(chan int, numJobs)
results := make(chan int, numJobs)
// 创建并启动多个工作 Goroutine
var wg sync.WaitGroup
for i := 1; i <= numWorkers; i++ {
wg.Add(1)
go func(workerID int) {
defer wg.Done()
worker(workerID, jobs, results)
}(i)
}
// 提供任务给工作 Goroutine
for i := 1; i <= numJobs; i++ {
jobs <- i
}
close(jobs)
// 等待所有工作完成
wg.Wait()
close(results)
// 收集任务结果
for result := range results {
fmt.Println("Result:", result)
}
}
在此示例中，我们创建了一些工作任务并将它们放入 jobs 通道中，然后启动了多个工作 Goroutine 来从 jobs 通道中获取任务并执行。每个工作 Goroutine 将结果发送到 results 通道中，然后主程序从 results 通道中收集结果。
并发数据处理：
假设您有一些数据需要并发地处理，您可以将数据分割成块，并使用 Goroutine 来并发处理每个块数据。下面是一个示例，展示如何使用 Goroutine 和 Channel 并发处理数据：
package main
import (
"fmt"
"sync"
)
func processData(data []int, results chan<- int) {
result := 0
for _, num := range data {
result += num
}
results <- result
}
func main() {
data := []int{
1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
const numWorkers = 3
chunkSize := len(data) / numWorkers
results := make(chan int, numWorkers)
var wg sync.WaitGroup
for i := 0; i < numWorkers; i++ {
wg.Add(1)
start := i * chunkSize
end := (i + 1) * chunkSize
go func() {
defer wg.Done()
processData(data[start:end], results)
}()
}
wg.Wait()
close(results)
totalResult := 0
for result := range results {
totalResult += result
}
fmt.Println("Total result:", totalResult)
}
在此示例中，我们将数据分割成多个块，每个块数据由一个工作 Goroutine 并发处理，然后将处理结果发送到 results 通道中。主程序等待所有工作完成，然后从 results 通道中收集处理结果并计算总和。
这只是一些示例，您可以根据具体的应用场景和需求，灵活地使用 Goroutine 和 Channel 来实现各种并发模式。
