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

当前位置： > > > > 如何在递归函数中设置互斥锁和sync.waitgroup？

来源：stackoverflow
2024-04-20 19:54:30
0浏览
收藏

你在学习Golang相关的知识吗？本文《如何在递归函数中设置互斥锁和sync.waitgroup？》，主要介绍的内容就涉及到，如果你想提升自己的开发能力，就不要错过这篇文章，大家要知道编程理论基础和实战操作都是不可或缺的哦！

问题内容

我在 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 的问题。

解决方案

递归没有什么本质上的特殊之处。互斥体、等待组或其他对象。它与任何函数调用相同。由于互斥体是可变的，因此您必须小心地通过指针传递它们 – 这应该是这样。要调试此问题，打印调用者和被调用者中对象的地址并确保它们是同一对象通常很有用。

快速浏览一下您的代码，每次调用 parseLink 都会创建一个新的互斥体和等待组，这是您想要的吗？

本篇关于《如何在递归函数中设置互斥锁和sync.waitgroup？》的介绍就到此结束啦，但是学无止境，想要了解学习更多关于Golang的相关知识，请关注公众号！