Go并发编程最佳实践习题题解

2024-07-28

背景介绍

环境

操作系统
- 本机：MacOS 15
- 远程：阿里云封装的centos
go版本
- 本机：go1.21.0
- 远程：go1.14.12
IDE：GoLand
辅助：ChatGPT 4o

$ cat /etc/os-release
NAME="Alibaba Cloud Linux"
VERSION="3 (Soaring Falcon)"
ID="alinux"
ID_LIKE="rhel fedora centos anolis"
VERSION_ID="3"
UPDATE_ID="9.1"
PLATFORM_ID="platform:al8"
PRETTY_NAME="Alibaba Cloud Linux 3 (Soaring Falcon)"
ANSI_COLOR="0;31"
HOME_URL="https://www.aliyun.com/"

必做题

作业内容

使⽤任意并发⼯具，完成这样⼀个程序，并发请求 https://baidu.com 和 https://bing.com，任意⼀个站点先获取到了完整的 html，即中⽌另⼀个流程，并把结果输出⾄⽂件：{sitename}.html，例如百度先获取到了结果，即输出baidu.html，若 bing 先获取到了结果，就输出 bing.html。

作业分析

这里需要两个爬虫并行，那么肯定是需要起goroutine的
爬虫可能会超时，所以可以考虑设置一个带超时时间的context来做
两个爬虫一但一个完成，另一个需要马上中止，而http.Get方法是很难中止的，所以这里用了http.NewRequestWithContext来实现
为了显式地看到另一个爬虫确实被中止了，这里用sync.WaitGroup来进行了一个等待
由于close时也可能报错，但同时又想作为defer处理，所以弄了个defer func，显式去修改返回的err值

实现

package main

import (
	"context"
	"fmt"
	"io"
	"net/http"
	"os"
	"sync"
	"time"
)

const (
	BaiduUrl = "https://www.baidu.com"
	BingUrl  = "https://www.bing.com"
)

func crawler(ctx context.Context, website string) (content string, err error) {
	req, err := http.NewRequestWithContext(ctx, "GET", website, nil)
	if err != nil {
		fmt.Printf("http.NewRequestWithContext err: %v\n", err)
		return
	}
	client := http.Client{}
	resp, err := client.Do(req)
	if err != nil {
		fmt.Printf("http.Get err: %v\n", err)
		return
	}
	defer func() {
		if resp != nil {
			err = resp.Body.Close()
		}
	}()

	var contentByte []byte
	contentByte, err = io.ReadAll(resp.Body)
	if err != nil {
		fmt.Printf("Read err: %v\n", err)
		return
	}
	content = string(contentByte)
	return
}

func crawlerWrapper(ctx context.Context, website string, result chan string, cancelFunc context.CancelFunc, wg *sync.WaitGroup) {
	defer wg.Done()
	content, err := crawler(ctx, website)
	if err != nil {
		fmt.Printf("Crawler err: %v\n", err)
	} else {
		select {
		case <-ctx.Done():
			fmt.Println("CrawlerWrapper Stopped")
			return
		case result <- content:
			cancelFunc()
		}
	}
}

func writeFile(filename, content string) (err error) {
	file, err := os.Create(filename)
	if err != nil {
		return
	}
	defer func() {
		err = file.Close()
	}()
	_, err = file.WriteString(content)
	return
}

func main() {
	ctx, cancel := context.WithCancel(context.Background())
	result := make(chan string)

	var wg sync.WaitGroup

	wg.Add(2)

	go crawlerWrapper(ctx, BaiduUrl, result, cancel, &wg)
	go crawlerWrapper(ctx, BingUrl, result, cancel, &wg)

	t := time.NewTimer(10 * time.Second)
	defer t.Stop()

	select {
	case <-t.C:
		fmt.Printf("Timeout\n")
	case res := <-result:
		err := writeFile("crawler.html", res)
		if err != nil {
			fmt.Printf("WriteFile err: %v\n", err)
		} else {
			fmt.Printf("WriteFile success\n")
		}
	}
	wg.Wait()
}

运行结果

文件被写入，同时显式地可以看到另一个爬虫被中止

1
2
3

http.Get err: Get "https://www.bing.com": context canceled
Crawler err: Get "https://www.bing.com": context canceled
WriteFile success

选做一

作业内容

安装 herdtools (https://github.com/herd/herdtools7)，在本机上使⽤ litmus7 执⾏下列脚本：

X86 OOO 
{ x=0; y=0; } 
 P0 | P1 ; 
 MOV [x],$1 | MOV [y],$1 ; 
 MOV EAX,[y] | MOV EAX,[x] ; 
locations [x;y;] 
exists (0:EAX=0 /\ 1:EAX=0)

并阅读明⽩输出结果，⽆需提交。

选做二

作业内容n

为什么使⽤ atomic.cas 可以实现⼀个互斥锁，为什么临界区内的内存读写操作不会被重排到 cas 操作之外？