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。递归没有天生的特殊之处。互斥体，等待组或其他对象。它与任何函数调用相同。由于互斥锁是可变的，因此您必须小心通过指针传递它们-那就应该如此。要进行调试，通常在调用方和被调用方中打印对象的地址并确保它们是同一对象通常很有用。

要获得有关代码段的更多具体帮助，建议您将其最小化，以更简单地说明问题：https://stackoverflow.com/help/mcve

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

如何在递归函数中设置互斥锁和sync.waitgroup？

1 个答案: