使用 timer 定时
    执行命令怎么做到计时执行这个事情呢？Golang 有个标准库 time，里面提供一个计时器 timer 的结构，是否可以使用这个 timer 来执行呢？我们先来看看 timer 是怎么使用的：

    2. func main() { 
    3.   timer := time.NewTimer(3 * time.Second) // 定一个计时器，3s后触发
    4.   select { 
    5.     now <-timer.C:  // 监听计时器中的事件
    6.       fmt.Println("3秒执行任务, 现在时间", now)  //3s后执行
    7.   } 
    8. }

    如果有一堆定时任务，要怎么定时执行呢？

    2. // Entity代表每个定时任务
    3. entries := []Entry  
    5. // 计算每个定时任务时间
    6. for _, entry := range entries {
    7.   entry.Next = next(entry)
    8. }
    10. for {
    11.     // 根据Next时间排序
    12.     sortByTime(entries)
    14.     // 创建计时器
    15.     timer = time.NewTimer(entries.Early.Sub(time.Now())) 
    17.     select {
    18.       case now = <-timer.C:
    19.         for _, entry := entries {
    20.           // 对已经到了时间的任务，执行
    21.           if entry.Next.Ok() {
    22.             go startJob(entry)
    23.           }
    25.           // 所有任务重新计算下个timer
    26.           entry.Next = next(entry)
    27.         }
    28.     }
    29. }

    使用 cron 包定时执行命令

    2. // 创建一个cron实例
    3. c := cron.New()
    5. // 每整点30分钟执行一次
    6. c.AddFunc("30 * * * *", func() { 
    7.   fmt.Println("Every hour on the half hour") 
    8. })
    9. // 上午3-6点，下午8-11点的30分钟执行
    10. c.AddFunc("30 3-6,20-23 * * *", func() {
    11.   fmt.Println(".. in the range 3-6am, 8-11pm") 
    12. })
    13. // 东京时间4:30执行一次
    14. c.AddFunc("CRON_TZ=Asia/Tokyo 30 04 * * *", func() { 
    15.   fmt.Println("Runs at 04:30 Tokyo time every day") 
    16. })
    17. // 从现在开始每小时执行一次
    18. c.AddFunc("@hourly",      func() { 
    19.   fmt.Println("Every hour, starting an hour from now") 
    20. })
    21. // 从现在开始，每一个半小时执行一次
    22. c.AddFunc("@every 1h30m", func() { 
    23.   fmt.Println("Every hour thirty, starting an hour thirty from now") 
    24. })
    26. // 启动cron
    27. c.Start()
    29. ...
    30. // 在cron运行过程中增加任务
    31. c.AddFunc("@daily", func() { fmt.Println("Every day") })
    32. ..
    33. // 查看运行中的任务
    34. inspect(c.Entries())
    35. ..
    36. // 停止cron的运行，优雅停止，所有正在运行中的任务不会停止。
    37. c.Stop()

    SpecSchedule包秒级别的定时

    2. // 创建一个cron实例
    3. c := cron.New(cron.WithParser(cron.NewParser(cron.SecondOptional | cron.Minute | cron.Hour | cron.Dom | cron.Month | cron.Dow | cron.Descriptor)))
    5. // 每秒执行一次
    6. c.AddFunc("* * * * * *", func() { 
    7.   fmt.Println("Every hour on the half hour") 
    8. })

    在 cron 库中，增加一个定时任务的 AddFunc 方法，有两个参数：时间描述语言、匿名函数。那么明显，AddCronCommand 函数中核心要做的，就是将 Command 结构的执行封装成一个匿名函数，再调用 cron 的 AddFunc 方法就可以了。

    因为在 Golang 中，fork 可以启动一个子进程，但是这个子进程是无法继承父进程的调度模型的。Golang 的调度模型是在用户态的 runtime 中自己进行调度的，而系统调用 fork 出来的子进程默认只会有单线程。所以在 Golang 中尽量不要使用 fork 的方式来复制启动当前进程。

    另一个办法是使用 os.StartProcess 来启动一个进程，执行当前进程相同的二进制文件以及当前进程相同的参数。

    https://github.com/sevlyar/go-daemon
    https://github.com/sevlyar/retag

    如何实现分布式定时器

    先定义接口，这个接口的功能是一个分布式的选择器，当有很多节点要执行某个服务的时候，只选择出其中一个节点。这样不管底层是否用 Redis 实现分布式选择器，在业务层我们都可以不用关心。

    2. package contract
    4. import "time"
    6. // DistributedKey 定义字符串凭证
    7. const DistributedKey = "hade:distributed"
    9. // Distributed 分布式服务
    10. type Distributed interface {
    11.    // Select 分布式选择器, 所有节点对某个服务进行抢占，只选择其中一个节点
    12.    // ServiceName 服务名字
    13.    // appID 当前的AppID
    14.    // holdTime 分布式选择器hold住的时间
    15.    // 返回值
    16.    // selectAppID 分布式选择器最终选择的App
    17.    // err 异常才返回，如果没有被选择，不返回err
    18.    Select(serviceName string, appID string, holdTime time.Duration) (selectAppID string, err error)
    19. }

    这个具体实现就有很多方式了，Redis 只是其中一种而已，而且 Redis 要到后面章节才能引入。这里就实现一个本地文件锁。当一个服务器上有多个进程需要进行抢锁操作，文件锁是一种单机多进程抢占的很简易的实现方式。在 Golang 中，其使用方法也比较简单。

    多个进程同时使用 os.OpenFile 打开一个文件，并使用 syscall.Flock 带上 syscall.LOCK_EX 参数来对这个文件加文件锁，这里只会有一个进程抢占到文件锁，而其他抢占不到的进程从 syscall.Flock 函数中获取到的就是 error。根据这个 error 是否为空，我们就能判断是否抢占到了文件锁。

    释放文件锁有两种方式，一种方式是调用 syscall.Flock 带上 syscall.LOCK_UN 的参数，另外一种方式是抢占到锁的进程结束，也会自动释放文件锁。

    本地文件锁的具体实现

    2. // Select 为分布式选择器
    3. func (s LocalDistributedService) Select(serviceName string, appID string, holdTime time.Duration) (selectAppID string, err error) {
    4.    appService := s.container.MustMake(contract.AppKey).(contract.App)
    5.    runtimeFolder := appService.RuntimeFolder()
    6.    lockFile := filepath.Join(runtimeFolder, "disribute_"+serviceName)
    7.    // 打开文件锁
    8.    lock, err := os.OpenFile(lockFile, os.O_RDWR|os.O_CREATE, 0666)
    9.    if err != nil {
    10.       return "", err
    11.    }
    12.    // 尝试独占文件锁
    13.    err = syscall.Flock(int(lock.Fd()), syscall.LOCK_EX|syscall.LOCK_NB)
    14.    // 抢不到文件锁
    15.    if err != nil {
    16.       // 读取被选择的appid
    17.       selectAppIDByt, err := ioutil.ReadAll(lock)
    18.       if err != nil {
    19.          return "", err
    20.       }
    21.       return string(selectAppIDByt), err
    22.    }
    23.    // 在一段时间内，选举有效，其他节点在这段时间不能再进行抢占
    24.    go func() {
    25.       defer func() {
    26.          // 释放文件锁
    27.          syscall.Flock(int(lock.Fd()), syscall.LOCK_UN)
    28.          // 释放文件
    29.          lock.Close()
    30.          // 删除文件锁对应的文件
    31.          os.Remove(lockFile)
    32.       }()
    33.       // 创建选举结果有效的计时器
    34.       timer := time.NewTimer(holdTime)
    35.       // 等待计时器结束
    36.       <-timer.C
    37.    }()
    38.    // 这里已经是抢占到了，将抢占到的appID写入文件
    39.    if _, err := lock.WriteString(appID); err != nil {
    40.       return "", err
    41.    }
    42.    return appID, nil
    43. }

    分布式选举

    2. // AddDistributedCronCommand 实现一个分布式定时器
    3. // serviceName 这个服务的唯一名字，不允许带有空格
    4. // spec 具体的执行时间
    5. // cmd 具体的执行命令
    6. // holdTime 表示如果我选择上了，这次选择持续的时间，也就是锁释放的时间
    7. func (c *Command) AddDistributedCronCommand(serviceName string, spec string, cmd *Command, holdTime time.Duration) {
    8.    root := c.Root()
    9.    // 初始化cron
    10.    if root.Cron == nil {
    11.       root.Cron = cron.New(cron.WithParser(cron.NewParser(cron.SecondOptional | cron.Minute | cron.Hour | cron.Dom | cron.Month | cron.Dow | cron.Descriptor)))
    12.       root.CronSpecs = []CronSpec{}
    13.    }
    14.    // cron命令的注释，这里注意Type为distributed-cron，ServiceName需要填写
    15.    root.CronSpecs = append(root.CronSpecs, CronSpec{
    16.       Type:        "distributed-cron",
    17.       Cmd:         cmd,
    18.       Spec:        spec,
    19.       ServiceName: serviceName,
    20.    })
    21.    appService := root.GetContainer().MustMake(contract.AppKey).(contract.App)
    22.    distributeServce := root.GetContainer().MustMake(contract.DistributedKey).(contract.Distributed)
    23.    appID := appService.AppID()
    24.    // 复制要执行的command为cronCmd，并且设置为rootCmd
    25.    var cronCmd Command
    26.    ctx := root.Context()
    27.    cronCmd = *cmd
    28.    cronCmd.args = []string{}
    29.    cronCmd.SetParentNull()
    30.    // cron增加匿名函数
    31.    root.Cron.AddFunc(spec, func() {
    32.       // 防止panic
    33.       defer func() {
    34.          if err := recover(); err != nil {
    35.             log.Println(err)
    36.          }
    37.       }()
    38.       // 节点进行选举，返回选举结果
    39.       selectedAppID, err := distributeServce.Select(serviceName, appID, holdTime)
    40.       if err != nil {
    41.          return
    42.       }
    43.       // 如果自己没有被选择到，直接返回
    44.       if selectedAppID != appID {
    45.          return
    46.       }
    47.       // 如果自己被选择到了，执行这个定时任务
    48.       err = cronCmd.ExecuteContext(ctx)
    49.       if err != nil {
    50.          log.Println(err)
    51.       }
    52.    })
    53. }

    问答：
    一个节点是一台服务器还是运行一次程序就是一个节点，多个节点怎么？
    多个节点即可以是一个服务器一个，也可以是多个进程。不过一般现在容器化这么普遍的情况，基本上一个节点在实际上上一个pod的概念

    问答：
    linux cron 命令会把任务写入 crontab 文件，而这里的代码似乎没有存储cron任务，所以cron任务其实是写死在app里并从命令行启动的？
    这样似乎会带来一些额外的开发和运维工作，比如需要新增和修改cron任务时就需要升级app并重新部署。 在分布式调度cron任务时还会有个问题，在同一个环境中启动多个app实例去抢占执行cron任务的话就只会记下最后一个pid，那么那些管理cron任务的子命令就都失效了。所以分布式调度必然意味着需要分布式部署？

    第一个问题，是的，cron是写在app里面运行的，每次升级cron需要升级app。第二个问题是存在这样问题，这个之前没考虑到，同一个目录启动多个实例。标准办法应该是每个实例启动一个runtimefolder，把runtimefolder从环境变量中传递进去才行