当前位置：首页 > article >正文

15分钟学 Go 第 47 天：并发进阶——深入了解Go语言的并发模型！

article 2024/11/14 20:46:01

第47天的学习：并发进阶——深入了解Go语言的并发模型！

操作	解释
创建Channel	`c := make(chan int)`
发送数据	`c <- x`（在goroutine中执行）
接收数据	`x := <-c`

package main

import (
	"fmt"
	"time"
)

func fibonacci(c, quit chan int) {
	x, y := 0, 1
	for {
		select {
		case c <- x:
			x, y = y, x+y
		case <-quit:
			fmt.Println("quit")
			return
		}
	}
}

func main() {
	c := make(chan int)
	quit := make(chan int)

	go func() {
		for i := 0; i < 10; i++ {
			fmt.Println(<-c)
		}
		quit <- 0
	}()
	fibonacci(c, quit)
}

作用：

多路复用：监听多个Channel。
处理超时：结合time.After实现超时控制。

5. 并发模型设计模式

工作池模型

用于限制同时运行的goroutines数目。

package main

import (
	"fmt"
	"time"
)

func worker(id int, jobs <-chan int, results chan<- int) {
	for j := range jobs {
		fmt.Printf("worker %d started job %d\n", id, j)
		time.Sleep(time.Second)
		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)

	for w := 1; w <= 3; w++ {
		go worker(w, jobs, results)
	}

	for j := 1; j <= numJobs; j++ {
		jobs <- j
	}
	close(jobs)

	for a := 1; a <= numJobs; a++ {
		<-results
	}
}

Pipeline模式

用于串联多个处理阶段。

package main

import (
	"fmt"
)

func gen(nums ...int) <-chan int {
	out := make(chan int)
	go func() {
		for _, n := range nums {
			out <- n
		}
		close(out)
	}()
	return out
}

func sq(in <-chan int) <-chan int {
	out := make(chan int)
	go func() {
		for n := range in {
			out <- n * n
		}
		close(out)
	}()
	return out
}

func main() {
	c := gen(2, 3, 4)
	out := sq(c)

	for n := range out {
		fmt.Println(n)
	}
}

6. 实战案例分析

为了进一步巩固理解，我们来看一个具体的并发应用示例。

案例：并发Web爬虫

目标：使用并发从多个URL抓取页面标题。

package main

import (
	"fmt"
	"net/http"
	"io/ioutil"
	"regexp"
	"time"
)

func fetch(url string, ch chan<- string) {
	start := time.Now()
	resp, err := http.Get(url)
	if err != nil {
		ch <- fmt.Sprintf("Error: %s", err)
		return
	}
	defer resp.Body.Close()

	body, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		ch <- fmt.Sprintf("Error reading body: %s", err)
		return
	}

	re := regexp.MustCompile("<title>(.*?)</title>")
	matches := re.FindStringSubmatch(string(body))
	title := "No title found"
	if len(matches) > 1 {
		title = matches[1]
	}

	secs := time.Since(start).Seconds()
	ch <- fmt.Sprintf("%.2f seconds: %s", secs, title)
}

func main() {
	urls := []string{
		"https://golang.org",
		"https://godoc.org",
		"https://gopl.io",
		"https://play.golang.org",
	}

	ch := make(chan string)
	for _, url := range urls {
		go fetch(url, ch)
	}

	for range urls {
		fmt.Println(<-ch)
	}
}