goroutine在超时后自动退出

在IT行业这个发展更新速度很快的行业，只有不停止的学习，才不会被行业所淘汰。如果你是Golang学习者，那么本文《goroutine在超时后自动退出》就很适合你！本篇内容主要包括##content_title##，希望对大家的知识积累有所帮助，助力实战开发！

我正在尝试用 go 编写一个类似于 cron 的程序，此外，作业被赋予了最大运行时间，如果函数超过了这个持续时间，作业应该退出。这是我的整个代码：

package main

import (
    "fmt"
    "log"
    "sync"
    "time"
)

type job struct {
    id         string
    maxruntime time.duration
    frequency  time.duration
    function   func()
}

func testfunc() {
    log.println("opp11")
    time.sleep(7 * time.second)
    log.println("op222")
}

func new(id, frequency, runtime string, implementation func()) job {
    r, err := time.parseduration(runtime)

    if err != nil {
        panic(err)
    }

    f, err := time.parseduration(frequency)

    if err != nil {
        panic(err)
    }

    j := job{id: id, maxruntime: r, frequency: f, function: implementation}
    log.printf("created job %#v with frequency %v and max runtime %v", id, f, r)
    return j
}

func (j job) run() {

    for range time.tick(j.frequency) {
        start := time.now()
        log.printf("job %#v executing...", j.id)
        done := make(chan int)
        //quit := make(chan int)
        //var wg sync.waitgroup
        //wg.add(1)

        go func() {
          j.function()
          done <- 0
        }()

        select {
        case <-done:
            elapsed := time.since(start)
            log.printf("job %#v completed in %v \n", j.id, elapsed)
        case <-time.after(j.maxruntime):
            log.printf("job %#v halted after %v", j.id, j.maxruntime)
            // here should exit the above goroutine
        }
    }

}

func main() {
    // create a new job given its name, frequency, max runtime
    // and the function it should run
    testjob := new("my-first-job", "3s", "5s", func() {
        testfunc()
    })

    testjob.run()
}

我想做的是，在选择 run() 函数的第二种情况下，它应该退出正在运行该函数的 goroutine。我尝试通过使用 select 语句将函数包装在 for 循环中来实现此目的，该语句侦听退出通道，如下所示：

go func() {
    for {
        select {
        case <-quit:
            fmt.Println("quiting goroutine")
            return
        default:
            j.Function()
            done <- 0
        }
    }
}()

然后在 run() 函数中使用 quit <- 1 ，但这似乎没有做任何事情。有更好的做法吗？

正确答案

正如评论中所解释的，整个问题是您想要取消不可取消的函数（j.function）的执行。

没有办法“杀死一个 goroutine”。 goroutines 以合作的方式工作。如果你希望能够“杀死它”，你需要确保在该 goroutine 中运行的函数有一种机制，可以让你发出信号，表明它应该停止正在执行的操作并返回，让运行它的 goroutine 最终终止。

指示函数可取消的标准方法是让它采用 context.context 作为其第一个参数：

type job struct {
  // ...
  function func(context.context)
}

然后创建上下文并将其传递给 j.function。由于您的取消逻辑只是基于超时，因此无需编写所有 select ... case <-time.after(...)，因为它是作为 context.context 的内置功能提供的：

func (j job) run() {
  for range time.tick(j.frequency) {
    go j.executeonce()
  }
}

func (j job) executeonce() {
  log.printf("job %#v executing...", j.id)
  ctx, cancel := context.withtimeout(context.background(), j.maxruntime)
  defer cancel()
  j.function(ctx)
}

现在，为了完成，您必须重写要传递给作业调度程序的函数，以便它们采用 context.context，并且非常重要的是，它们使用正确并在上下文取消时取消他们正在做的任何事情。

这意味着，如果您正在为这些函数编写代码，并且它们会以某种方式阻塞，那么您将负责编写如下内容：

select {
case <-ctx.Done():
  return ctx.Err()
case ...your blocking case...:
}

如果您的函数正在调用第 3 方代码，那么该代码需要了解上下文和取消，并且您需要传递您的函数收到的 ctx。

好了，本文到此结束，带大家了解了《goroutine在超时后自动退出》，希望本文对你有所帮助！关注golang学习网公众号，给大家分享更多Golang知识！