我想创建一个调度程序，例如它每秒执行一个任务，但也希望有一个 http 接口(interface)来停止/启动调度程序并获取更多统计信息/信息，阅读更多关于 timers & tickers 的信息后, channels和 gorutines我想出了这个:

https://gist.github.com/nbari/483c5b382c795bf290b5

package main

import (
    "fmt"
    "log"
    "net/http"
    "time"
)

var timer *time.Ticker

func scheduler(seconds time.Duration) *time.Ticker {
    ticker := time.NewTicker(seconds * time.Second)
    go func() {
        for t := range ticker.C {
            // do stuff
            fmt.Println(t)
        }
    }()
    return ticker
}

func Start(timer *time.Ticker) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        timer = scheduler(1)
        w.Write([]byte("Starting scheduler"))
    })
}

func Stop(timer *time.Ticker) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        timer.Stop()
        w.Write([]byte("Stoping scheduler"))
    })
}

func main() {
    timer = scheduler(1)
    http.Handle("/start", Start(timer))
    http.Handle("/stop", Stop(timer))
    log.Fatal(http.ListenAndServe(":8080", nil))
}

上面的代码有效，但我有一个全局“定时器”变量，我想知道是否有更好的方法来实现它以及处理多个调度程序的方法，目前正在考虑可能实现的一种所有调度程序的容器，但希望有一些反馈可以帮助我找到聪明的解决方案。

最佳答案

是的，有更好的方法:

您应该在此处使用 channel ，并且如您所建议的那样，使用一些数据结构来容纳更多调度程序。

我想到了这个，这是我要做的最基本的工作示例:

package main

import (
    "errors"
    "fmt"
    "sync"
    "time"
)

// a scheduler runs f on every receive on t and exits when receiving from quit is non-blocking
type scheduler struct {
    t    <-chan time.Time
    quit chan struct{}
    f    func()
}

// a schedulerPool holds multiple schedulers
type schedulerPool struct {
    schedulers map[int]scheduler //I used a map here so you can use more clever keys
    counter    int
    mut        sync.Mutex
}

func newPool() *schedulerPool {
    return &schedulerPool{
        schedulers: make(map[int]scheduler),
    }
}

// start adds and starts a new scheduler that will execute f every interval.
// It returns the generated ID for the scheduler, or an error.
func (p *schedulerPool) start(interval time.Duration, f func()) (int, error) {
    p.mut.Lock()
    defer p.mut.Unlock()
    index := p.counter
    p.counter++

    if _, ok := p.schedulers[index]; ok {
        return 0, errors.New("key already in use")
    }

    sched := scheduler{
        t:    time.NewTicker(interval).C,
        quit: make(chan struct{}),
        f:    f,
    }

    p.schedulers[index] = sched
    go func() {
        for {
            select {
            case <-sched.t:
                sched.f()
            case <-sched.quit:
                return
            }
        }
    }()
    return index, nil
}

// stop stops the scheduler with the given ID.
func (p *schedulerPool) stop(index int) error {
    p.mut.Lock()
    defer p.mut.Unlock()

    sched, ok := p.schedulers[index]
    if !ok {
        return errors.New("does not exist")
    }

    close(sched.quit)
    return nil
}

func main() {
    // get a new pool
    pool := newPool()

    // start a scheduler
    idx1, err := pool.start(time.Second, func() { fmt.Println("hello 1") })
    if err != nil {
        panic(err)
    }

    // start another scheduler
    idx2, err := pool.start(time.Second, func() { fmt.Println("hello 2") })
    if err != nil {
        panic(err)
    }

    // wait some time
    time.Sleep(3 * time.Second)

    // stop the second scheduler
    err = pool.stop(idx2)
    if err != nil {
        panic(err)
    }

    // wait some more
    time.Sleep(3 * time.Second)

    // stop the first scheduler
    err = pool.stop(idx1)
    if err != nil {
        panic(err)
    }
}

在 playground 上查看.

请注意，不能保证第一个调度程序总共运行六次，而第二个调度程序总共运行三次。

另请注意我所做的其他一些事情:

• 必须同步 map 访问
• 生成的 ID 必须同步
• 您应该检查 key 是否确实在 map 中
• 使用 channel 启动、停止和控制调度器(例如，添加 channel beep 让调度器将某些内容转储到控制台(如 “beep”))
• 为要执行的函数的确切签名定义一个类型，例如 type schedFunc func(int, int)

显然，您需要将这些东西包装在 http 处理程序中，可能从查询字符串中获取 ID 或参数，或者其他一些奇特的东西。这只是为了演示。

关于go - 通过 http 启动/停止和处理自定义调度程序，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/33413105/