go - 如何在递归函数中设置mutex和sync.waitgroup？

Question

我用 Go 编写了一些代码来解析站点并检索所有链接及其 Http 响应。我的代码运行良好，但我想添加 GoRoutines 以查看它在递归函数中的工作方式。

package main
import (
    "fmt"
    "io/ioutil"
    "net/http"
    "regexp"
    "strings"
    "sync"
)

type linkWeb struct {
    Link string
    Code string
}

func parseLink(siteName string, arrayError []linkWeb) (arrayResult []linkWeb) {
    var mutex = &sync.Mutex{}
    var wg = sync.WaitGroup{}
    var baseSite = siteName
    site, _ := http.Get(baseSite)
    html, _ := ioutil.ReadAll(site.Body)
    errorCodeHTTP := site.Status
    mutex.Lock()
    errorArray := arrayError
    mutex.Unlock()
    allJs := regexp.MustCompile(`src="[^"]*"+`)
    allA := regexp.MustCompile(`(.)*href="[^"]*"+`)
    var resultsJs = allJs.FindAllStringSubmatch(string(html), -1)
    var resultUrls = allA.FindAllStringSubmatch(string(html), -1)
    resultsJs = append(resultsJs, resultUrls...)
    for _, linkJs := range resultsJs {
        wg.Add(1)
        go func() {
            re := regexp.MustCompile(`(href|src)(.)*="[^"]*"`)
            var execReg = re.FindAllStringSubmatch(linkJs[0], -1)
            link := regexp.MustCompile(`"(.)*"`)
            var linkCenter = link.FindAllStringSubmatch(execReg[0][0], -1)
            resultrmvbefore := strings.TrimPrefix(linkCenter[0][0], "\"")
            resultrmvafter := strings.TrimSuffix(resultrmvbefore, "\"")
            var already = 0
            mutex.Lock()
            for _, itemURL := range errorArray {
                if resultrmvafter == itemURL.Link {
                    already = 1
                }
            }
            mutex.Unlock()
            if already == 0{
                var actualState = linkWeb{resultrmvafter, "-> " + errorCodeHTTP + "\r\n"}
                mutex.Lock()
                errorArray = append(errorArray, actualState)
                mutex.Unlock()
                return
            } else {
                if already == 0 {
                    var actualState = linkWeb{resultrmvafter, "-> " + errorCodeHTTP + "\r\n"}
                    mutex.Lock()
                    errorArray = append(errorArray, actualState)
                    var arrayReturn = errorArray
                    mutex.Unlock()
                    parseLink(resultrmvafter, arrayReturn)
                }
            }
            wg.Done()
        }()
    }
    wg.Wait()
    return
}
func main() {
    var arrayError []linkWeb
    var resultArray = parseLink("https://www.golem.ai/", arrayError)
}

我只是不知道是否有必要将我的 syncGroup 作为函数参数传递，因为我进行了测试，但没有看到任何变化。我阅读了文档，但我不知道我的问题是否与我的递归函数有关，或者是我对 Golang 不了解的问题。非常感谢您的帮助:)

Answer 1

递归 w.r.t 本身并没有什么特别之处。互斥量、 WaitGroup 或其他对象。它与任何函数调用相同。由于互斥量是可变的，因此您必须小心地通过指针传递它们——应该就是这样。要对此进行调试，打印调用者和被调用者中对象的地址并确保它们是同一对象通常很有用。

为了获得有关您的代码片段的更具体的帮助，我建议您将它最小化为更简单的东西来演示您的问题:https://stackoverflow.com/help/mcve

通过快速查看您的代码，每次调用 parseLink 都会创建一个新的互斥锁和 WaitGroup ，这是您想要的吗？