函数称自己为goroutine，这是否危险？

我不确定这是否会产生泄漏。我假设，由于在启动go例程后返回函数

GetFile

，因此可能没有问题。但我不确定这是否是个问题，例如，很久没有找到文件了

func (p *MyStruct) Launch() {
   go p.Generate()
}

func (p *MyStruct) Generate() {
    file := p.GetFile()
    if file == "" {
         return
    }

    // Do stuff with the file
}

func (p *MyStruct) GetFile() string {
    // Get file
    *p.SyncChan <- id
    fileToProcess, err := tools.ReserveFile(p.Name, id, p.BufferIndex)
    <- *p.SyncChan

    if fileToProcess == "" {
        time.Sleep(time.Minute * 6)
        go p.Generate()
        return ""
    }
    return fileToProcess
}

func（p*MyStruct）启动（）{
go p.Generate（）
}
func（p*MyStruct）Generate（）{
文件：=p.GetFile（）
如果文件==“”{
返回
}
//处理文件
}
func（p*MyStruct）GetFile（）字符串{
//获取文件
*p、 不，递归不是问题所在。问题是，当你开始一个goroutine时，你应该始终考虑goroutine的结尾。另外，创建一个新的goroutine没有任何好处，为什么不使用一个普通的递归呢？我这样做是因为它让我感觉更干净（我可能是错的，呵呵）。另外，由于应用程序的构建方式，我不需要跟踪goroutines，如果它们自己退出也没关系。当您编写
p.Generate（）
而不是
go p.Generate（）时，有什么更清晰的地方
？您正在使用
*MyStruct
。在不同的goroutine之间传递此指针可能会产生数据争用和非常严重的错误。您的代码很难阅读。问题是
GetFile（）
的作用是：每6分钟尝试重新服务一个文件，直到您可以保留它。如果您使用for循环，您的代码将更容易理解。是的，这是真的，这样做的目的是让我可以在执行过程中的任何时候回到Generate方法的开始，这段代码并不明显，因为它非常简单，但是想象一下在GetFile中有几个阶段，在任何时候我都可以回到生成的开始，我想知道启动一个go例程是否会从父函数中分离出来，因为一个普通的递归调用可能会填充堆栈跟踪？这是我不确定如何在go中处理的事情