Go语言的并发模型是其核心特性之一，它通过goroutines和channels提供了一种相对简单而强大的方式来处理并发任务。下面我将通过几个案例分析来展示Go语言并发模型的应用。
假设我们要构建一个并发HTTP服务器，该服务器能够同时处理多个客户端请求。我们可以使用goroutines来实现这一点。
package main
import (
"fmt"
"net/http"
)
func handler(w http.ResponseWriter, r *http.Request) {
fmt.Fprintf(w, "Hello, World!")
}
func main() {
http.HandleFunc("/", handler)
http.ListenAndServe(":8080", nil)
}
在上面的代码中，我们定义了一个简单的HTTP处理函数handler，它只是向客户端发送一条"Hello, World!"消息。在main函数中，我们使用http.HandleFunc将处理函数与路径"/"关联起来，并使用http.ListenAndServe启动服务器监听8080端口。由于HTTP请求是并发的，服务器会为每个请求创建一个新的goroutine来处理，从而实现并发处理。
假设我们要构建一个并发任务调度系统，该系统能够同时执行多个任务。我们可以使用goroutines和channels来实现这一点。
package main
import (
"fmt"
"sync"
)
func worker(id int, jobs <-chan int, results chan<- int) {
for j := range jobs {
fmt.Printf("Worker %d started job %d\n", id, j)
// 模拟任务执行时间
fmt.Printf("Worker %d finished job %d\n", id, j)
results <- j * 2
}
}
func main() {
const numJobs = 5
jobs := make(chan int, numJobs)
results := make(chan int, numJobs)
var wg sync.WaitGroup
for w := 1; w <= 3; w++ {
wg.Add(1)
go worker(w, jobs, results)
}
// 发送任务到jobs通道
for j := 1; j <= numJobs; j++ {
jobs <- j
}
close(jobs)
// 等待所有工作完成
wg.Wait()
// 打印结果
for a := 1; a <= numJobs; a++ {
fmt.Println("Result:", <-results)
}
}
在上面的代码中，我们定义了一个worker函数，它从jobs通道接收任务并执行，然后将结果发送到results通道。在main函数中，我们创建了三个工作goroutine，并使用sync.WaitGroup来等待它们完成。然后，我们向jobs通道发送任务，并在所有任务完成后关闭通道。最后，我们从results通道接收并打印结果。
假设我们要构建一个并发文件读写系统，该系统能够同时读取和写入多个文件。我们可以使用goroutines和channels来实现这一点。
package main
import (
"fmt"
"io/ioutil"
"os"
"sync"
)
func readFile(filename string, wg *sync.WaitGroup, results chan<- string) {
defer wg.Done()
data, err := ioutil.ReadFile(filename)
if err != nil {
results <- fmt.Sprintf("Error reading %s: %v", filename, err)
return
}
results <- string(data)
}
func writeFile(filename string, data string, wg *sync.WaitGroup) {
defer wg.Done()
err := ioutil.WriteFile(filename, []byte(data), 0644)
if err != nil {
fmt.Printf("Error writing %s: %v\n", filename, err)
return
}
}
func main() {
filenames := []string{"file1.txt", "file2.txt", "file3.txt"}
data := "Hello, World!"
var wg sync.WaitGroup
results := make(chan string, len(filenames))
// 启动读取goroutines
for _, filename := range filenames {
wg.Add(1)
go readFile(filename, &wg, results)
}
// 等待读取完成
go func() {
wg.Wait()
close(results)
}()
// 处理读取结果
for result := range results {
fmt.Println(result)
}
// 启动写入goroutines
for _, filename := range filenames {
wg.Add(1)
go writeFile(filename, data, &wg)
}
// 等待写入完成
wg.Wait()
fmt.Println("All files have been processed.")
}
在上面的代码中，我们定义了readFile和writeFile函数，分别用于读取和写入文件。在main函数中，我们创建了读取和写入goroutines，并使用sync.WaitGroup来等待它们完成。我们还使用了一个results通道来收集读取结果。最后，我们打印处理结果并等待所有写入操作完成。
这些案例展示了Go语言并发模型的强大功能和灵活性。通过使用goroutines和channels，我们可以轻松地构建并发应用程序，并有效地处理并发任务。
