func (e *EtcdDriver) SetHeartBeat(nodeID string) {
	leaseID, err := e.putKeyWithLease(nodeID, nodeID)
	if err != nil {
		log.Printf("putKeyWithLease error: %v", err)
		return
	}

	leaseRespChan, err := e.cli.KeepAlive(context.Background(), leaseID)

	if err != nil {
		log.Printf("keepalive error:%v", err)
		return
	}

         // 尝试修复
	go func (){
		for {
			select {
			case resp := <-leaseRespChan:
				if resp == nil {
					log.Printf("ectd cli keepalive unexpected nil")
				}
			case <-time.After(businessTimeout):
				log.Printf("ectd cli keepalive timeout")
			}
		}
	} ()
}

为什么不直接用分布式锁实现？
通过各个节点在定时任务内抢锁方式实现，需要依赖各个节点系统时间完全一致，当系统时间有误差时可能会导致以下问题：

如果任务的执行时间小于系统时间差，任务仍然会被重复执行（某个节点定时执行完毕释放锁，又被另一个因为系统时间之后到达定时时间的节点取得锁）。
即使有极小的误差，因为某个节点的时间会比其他节点靠前，在抢锁时能第一时间取得锁，所以导致的结果是所有任务都只会被该节点执行，无法均匀分布到多节点。

dcronDemo.AddFunc("s1 test1", "0 */1 * * * *", func() {
	fmt.Println("执行 service1 test1 任务", time.Now().Format("15:04:05"))
})
dcronDemo.AddFunc("s1 test2", "0 */1 * * * *", func() {
	fmt.Println("执行 service1 test2 任务", time.Now().Format("15:04:05"))
})


dcronDemo.AddFunc("s1 test3", "0 */1 * * * *", func() {
	fmt.Println("执行 service1 test3 任务", time.Now().Format("15:04:05"))
})
dcronDemo.Start()


//测试120分钟后退出
time.Sleep(120 * time.Minute)

panic: got 4 elements in cluster info address, expected 2 or 3

tg := new(product_platform.TaskGroup)
//每小时执行一次
//dcr.AddFunc("TestTask", "0 0 * * * *", tg.TestTask)
dCronEngine.AddFunc("GetBipData", "0 0 * * * *", tg.GetBipData)
dCronEngine.AddFunc("GetTeaData", "0 0 * * * *", tg.GetTeaData)
dCronEngine.Start()

func (d *Dcron) AddCmds(jobName, cronStr string, cmds []string) (err error) 

//JobWarpper is a job warpper
type JobWarpper struct {
	ID      cron.EntryID
	Dcron   *Dcron
	Name    string
	CronStr string
	Func    func()
	Job     Job

       Type      string // command, http, rpc etc. 任务类型
        Commands []string // 要执行的shell命令
       // 用于存储分隔后的任务
	cmd     []string
}



func (job *JobWarpper) splitCmd(i int) {
	job.cmd = strings.SplitN(job.Command[i], " ", 2)
}

func (job *JobWarpper) CmdRun() {
	var cmd *exec.Cmd
	var stdOut bytes.Buffer
	var stdErr bytes.Buffer
	var cmdStr string
	for i := range job.Commands {
		job.splitCmd(i)

		// 超时控制
		c := strings.Join(job.cmd, " ")
		fmt.Println(c)
		if job.Timeout > 0 {
			ctx, cancel := context.WithTimeout(context.Background(), time.Duration(job.Timeout)*time.Second)
			defer cancel()
			cmd = exec.CommandContext(ctx, "sh", "-c", c)
		} else {
			cmd = exec.Command("sh", "-c", c)
		}

		//cmd.SysProcAttr = sysProcAttr
		cmd.Stdout = &stdOut
		cmd.Stderr = &stdErr

		if i > 0 {
			cmdStr = cmdStr + "\n" + c
		} else {
			cmdStr = c
		}
		if err := cmd.Start(); err != nil {
			// 错误处理
			break
		}

		if err := cmd.Wait(); err != nil {
			// 错误处理
			if p, _ := os.FindProcess(cmd.Process.Pid); p != nil {
				// 无法杀死任务启动的子进程
				p.Kill()
			}
			// 告警之类
			break
		}
	}
	result := "------ " + cmdStr + " ----\n" + stdOut.String() + " ----\n" + stdErr.String()

	fmt.Println(result)
}

func (np *NodePool) monitorExit() {
	quit := make(chan os.Signal, 1)
	signal.Notify(quit, syscall.SIGHUP, syscall.SIGINT, syscall.SIGTERM, syscall.SIGQUIT)
	<-quit

	// 一些退出前  要做的节点处理逻辑 如关闭redis 连接 通知其他节点我退出了==
}

// WithLogger both set dcron and cron logger.
func WithLogger(logger interface{ Printf(string, ...interface{}) }) Option {
	return func(dcron *Dcron) {
		//set dcron logger
		dcron.logger = logger
		//set cron logger，这里设置的是标准日志输出，很多信息无法打印
		f := cron.WithLogger(cron.PrintfLogger(logger))
		dcron.crOptions = append(dcron.crOptions, f)
	}
}

// PrintfLogger wraps a Printf-based logger (such as the standard library "log")
// into an implementation of the Logger interface which logs errors only.
func PrintfLogger(l interface{ Printf(string, ...interface{}) }) Logger {
	return printfLogger{l, false}
}

// VerbosePrintfLogger wraps a Printf-based logger (such as the standard library
// "log") into an implementation of the Logger interface which logs everything.
func VerbosePrintfLogger(l interface{ Printf(string, ...interface{}) }) Logger {
	return printfLogger{l, true}
}

 c := cron.New(cron.WithSeconds()) 
 c.AddJob("* * * * * ?", job)
 c.Start()

 c := dcron.New(dcron.WithSeconds()) 
 c.AddJob("* * * * * ?", job)
 c.Start()

 c := dcron.New(dcron.WithSeconds(),dcron.WithDistributed(dcron.Driver)) 
 c.AddJob("* * * * * ?", job)
 c.Start()

module dcron-test

go 1.21

require (
	github.com/go-redis/redis/v8 v8.11.5
	github.com/libi/dcron v0.5.1
	gorm.io/gen v0.3.23
)

 go mod tidy
go: finding module for package go.opentelemetry.io/otel/internal/metric
go: finding module for package go.opentelemetry.io/otel/semconv
go: finding module for package go.opentelemetry.io/otel/unit   
go: found go.opentelemetry.io/otel/internal/metric in go.opentelemetry.io/otel/internal/metric v0.27.0
go: finding module for package go.opentelemetry.io/otel/metric/registry
go: finding module for package go.opentelemetry.io/otel/semconv
go: dcron-test/jobx imports                                                                                                                                    
        github.com/libi/dcron tested by                                                                                                                        
        github.com/libi/dcron.test imports                                                                                                                     
        go.etcd.io/etcd/tests/v3/integration imports                                                                                                           
        go.etcd.io/etcd/server/v3/embed imports                                                                                                                
        go.opentelemetry.io/otel/semconv: module go.opentelemetry.io/otel@latest found (v1.19.0), but does not contain package go.opentelemetry.io/otel/semconv
go: dcron-test/jobx imports
        github.com/libi/dcron tested by
        github.com/libi/dcron.test imports
        go.etcd.io/etcd/tests/v3/integration imports
        go.etcd.io/etcd/server/v3/embed imports
        go.opentelemetry.io/otel/exporters/otlp imports
        go.opentelemetry.io/otel/sdk/metric/controller/basic imports
        go.opentelemetry.io/otel/metric/registry: module go.opentelemetry.io/otel/metric@latest found (v1.19.0), but does not contain package go.opentelemetry.io/otel/metric/registry

	github.com/libi/dcron v0.2.2
	github.com/robfig/cron/v3 v3.0.1
[root@dev-node1-ops1 log]# go version
go version go1.19.10 linux/amd64

logger := log.New(os.Stdout, "[DCron]", log.LstdFlags)
rec := dcron.CronOptionChain(cron.Recover(cron.PrintfLogger(logger)))
dc := dcron.NewDcronWithOption("HbsCron", drv, rec, dcron.WithLogger(logger), dcron.WithHashReplicas(10), dcron.WithNodeUpdateDuration(time.Second*10))

dc.AddFunc("cache.WarmUPForCMDB()", g.Config().DCron.WarmUPForCMDB, func() {
	fmt.Println("DCron execute task: cache.WarmUPForCMDB()", time.Now().Format("15:04:05"))
	cache.WarmUPForCMDB()
})

dc.AddFunc("cache.LoopInit()", g.Config().DCron.LoopInit, func() {
	fmt.Println("DCron execute task: cache.LoopInit()", time.Now().Format("15:04:05"))
	cache.MonitoredHosts.Init()
	cache.MonitoredHosts.CorrectInitHost()
})

secondLevelCron.Start()

Nov 29 04:38:00 dev-node1-ops1 hbs: DCron execute secondLevelCron task: cache.DeliveryTimeoutCheck() 04:38:00
Nov 29 04:38:00 dev-node1-ops1 hbs: [DCron]2023/11/29 04:38:00 INFO: job 'cache.AutoAddStatusForMaintenance()' running in node
Nov 29 04:38:00 dev-node1-ops1 hbs: [DCron]2023/11/29 04:38:00 ERR: node pool is empty
Nov 29 04:38:00 dev-node1-ops1 hbs: [DCron]2023/11/29 04:38:00 INFO: job 'cache.PopulateWorkersByTeamManagers()' running in node
Nov 29 04:38:00 dev-node1-ops1 hbs: [DCron]2023/11/29 04:38:00 ERR: node pool is empty
Nov 29 04:38:00 dev-node1-ops1 hbs: [DCron]2023/11/29 04:38:00 INFO: job 'cache.SyncSpecifiedRecords()' running in node
Nov 29 04:38:00 dev-node1-ops1 hbs: [DCron]2023/11/29 04:38:00 INFO: job 'cache.SetStaleSysProperty()' running in node
Nov 29 04:38:00 dev-node1-ops1 hbs: [DCron]2023/11/29 04:38:00 ERR: node pool is empty
Nov 29 04:38:00 dev-node1-ops1 hbs: [DCron]2023/11/29 04:38:00 ERR: node pool is empty
Nov 29 04:38:00 dev-node1-ops1 hbs: [DCron]2023/11/29 04:38:00 INFO: job 'cache.CallIncident()' running in node
Nov 29 04:38:00 dev-node1-ops1 hbs: [DCron]2023/11/29 04:38:00 ERR: node pool is empty
Nov 29 04:38:00 dev-node1-ops1 hbs: [DCron]2023/11/29 04:38:00 INFO: job 'cache.GetCache2mongo()' running in node
Nov 29 04:38:00 dev-node1-ops1 hbs: [DCron]2023/11/29 04:38:00 ERR: node pool is empty