package main

import (
    "fmt"
    "time"
)

func task() {
    fmt.Println("任務執(zhí)行時間：", time.Now())
}

func main() {
    ticker := time.NewTicker(2 * time.Second)
    defer ticker.Stop()

    done := make(chan bool)

    go func() {
        for {
            select {
            case <-done:
                fmt.Println("調度器已停止")
                return
            case t := <-ticker.C:
                fmt.Println("調度器觸發(fā)：", t)
                task()
            }
        }
    }()

    // 模擬運行一段時間后終止
    time.Sleep(10 * time.Second)
    done <- true
}

type TaskFunc func()

type Scheduler struct {
    ticker  *time.Ticker
    quit    chan struct{}
    running bool
    mu      sync.Mutex
}

func NewScheduler(interval time.Duration, task TaskFunc) *Scheduler {
    return &Scheduler{
        ticker:  time.NewTicker(interval),
        quit:    make(chan struct{}),
        running: false,
    }
}

func (s *Scheduler) Start(task TaskFunc) {
    s.mu.Lock()
    if s.running {
        s.mu.Unlock()
        return
    }
    s.running = true
    s.mu.Unlock()

    go func() {
        for {
            select {
            case <-s.quit:
                return
            case <-s.ticker.C:
                task()
            }
        }
    }()
}

func (s *Scheduler) Stop() {
    s.mu.Lock()
    defer s.mu.Unlock()

    if s.running {
        close(s.quit)
        s.ticker.Stop()
        s.running = false
    }
}

func main() {
    scheduler := NewScheduler(3*time.Second, nil)
    scheduler.Start(func() {
        fmt.Println("執(zhí)行任務：", time.Now())
    })

    time.Sleep(10 * time.Second)
    scheduler.Stop()
    fmt.Println("調度器停止")
}