计时器分 Timer 和 Ticker 两种，它们底层基本是一样的，两差的区别请参考 https://blog.haohtml.com/archives/19859, 这里我们的介绍对象是 Timer 。

计时器结构体

https://github.com/golang/go/blob/go1.17.6/src/time/sleep.go#L84-L98

 // NewTimer creates a new Timer that will send
 // the current time on its channel after at least duration d.
 func NewTimer(d Duration) *Timer {
     c := make(chan Time, 1)
     t := &Timer{
         C: c,
         r: runtimeTimer{
             when: when(d),
             f:    sendTime,
             arg:  c,
         },
     }
     startTimer(&t.r)
     return t
 }

通过调用 NewTimer() 函数创建一个 Timer，首先创建一个长度为1的有缓冲channel，再创建一个Timer的结构体，并将 channel 置于 Timer 结构体内。

注意这里的 runtimeTimer.f 字段是一个函数 sendTime ，其实现如下

func sendTime(c interface{}, seq uintptr) {
	// Non-blocking send of time on c.
	// Used in NewTimer, it cannot block anyway (buffer).
	// Used in NewTicker, dropping sends on the floor is
	// the desired behavior when the reader gets behind,
	// because the sends are periodic.
	select {
	case c.(chan Time) <- Now():
	default:
	}
}

当 sendTime 函数主要用在 newTimer() 时，它以无阻塞的方式将当前时间 Now() 发送到 c 通道里。如果用在 newTicker() 时，如果读取落后，会将发送丢弃，它是周期性的。

我们给出 Timer 的结构体声明。

 type Timer struct {
     C <-chan Time
     r runtimeTimer
 }

一共两个字段，为了理解方面我们称 runtimeTimer 为 timer 值。

我们再看一下其中的 runtimeTimer 结构体的声明

 // Interface to timers implemented in package runtime.
 // Must be in sync with ../runtime/time.go:/^type timer
 type runtimeTimer struct {
     pp       uintptr
     when     int64
     period   int64
     f        func(interface{}, uintptr) // NOTE: must not be closure
     arg      interface{}
     seq      uintptr
     nextwhen int64
     status   uint32
 }

对于 runnerTimer结构体要与在 runtime/time.go 文件中的 timer 结构体保持同步。

结构体字段说明

• pp 指针类型，这里指 GPM 中的 P。如果这个计时器 timer 在一个heap 上，它在哪个 P 的堆上
• when 表示唤醒执行的时间，表示什么时间开始执行
• period 周期，一定是大于 0; when+period 表示下次唤醒执行的时间
• f 执行函数，不允许为匿名函数，最好为非阻塞函数
• arg 上面f函数的参数
• seq 同 arg，其在 runOneTimer 函数中的调用方式为 f(arg, seq)
• nextwhen 下次运行的时间，其值只有在 timerModifiedXX status 状态下才设置
• status 状态，其定义的的可用值有10种，定义在 runtime/time.go，我们下面对这些状态进行了介绍。

每次开启一个goroutine 执行 f(arg, now)，基中when表示执行的时间，而 when+period 表示下次执行的时间。(这时有点疑问，对调用的函数参数，f的第二个参数是 now, 但后面介绍的时候第二个参数却是 seq)

通过查看 https://github.com/golang/go/blob/go1.17.6/src/runtime/time.go#L41-L116 可知以下几点：

在执行 go build 命令的时候，经常需要添加一些参数，或许是为了调试，也或许是为了生成最终部署。

如果只在编译特定包时需要传递参数，格式应遵守“包名=参数列表”，如

go build -gcflags -gcflags='log=-N -l' main.go

-gcflags

go build 可以用 -gcflags 给go编译器传入参数，也就是传给 go tool compile 的参数，因此可以用 go tool compile –help 查看所有可用的参数。

其中 -m 可以检查代码的编译优化情况，包括逃逸情况和函数是否内联。

-ldflags

go build用 -ldflags 给go链接器传入参数，实际是给go tool link的参数，可以用go tool link –help查看可用的参数。

常用-X来指定版本号等编译时才决定的参数值。例如代码中定义var buildVer string，然后在编译时用go build -ldflags “-X main.buildVer=1.0” … 来赋值。注意-X只能给string类型变量赋值。

Golang中的编译参数

开发中经常使用 go build 命令来编译我们的程序源码，然后将生成二进制文件直接部署，极其方便。

对于 go build 有一些参数，对于针对程序源码进行一些编译优化，下面我们对经常使用的一些参数来介绍一下。

环境变量

环境变量需要在go命令前面设置，如果多个变量的话，中间需要用“空格”分隔。下面我们介绍一个非常常见到的一些环境变量

$ CGO_ENABLED=1 GOARCH=amd64 GOOS=linux go build -o myserver main.go

除了这里给出的这几个变量外，还有一些其它变量，如 GODEBUG、GOFLAGS、GOPROXY 等，所有支持环境变量都可以在 https://github.com/golang/go/blob/a88575d662a7e8e4fbb31bf139bcffc063e2a734/src/cmd/go/internal/help/helpdoc.go#L485 里找到，有兴趣的话可以看看他们的作用。

这里重点介绍一下 CGO_ENABLED 环境变量对我们程序的影响。 CGO_ENABLED是用来控制golang 编译期间是否支持调用 cgo 命令的开关，其值为1或0，默认情况下值为1，可以用 go env 查看默认值。

如果你的程序里调用了cgo 命令，此参数必须设置为1,否则将编译时出错。这里直接用文档 https://go.dev/blog/cgo 中的一个例子验证。

package main

// #include <stdio.h>
// #include <stdlib.h>
//
// static void myprint(char* s) {
//   printf("%sn", s);
// }
import "C"
import "unsafe"

func main() {
	cs := C.CString("Hello from stdio")
	C.myprint(cs)
	C.free(unsafe.Pointer(cs))
}

然后我们执行一下 启用 CGO_ENABLED=1 的情况

root@ubuntu:/home/sxf/gotest# CGO_ENABLED=1 go run main.go
root@ubuntu:/home/sxf/gotest# ./main
Hello from stdio

可以看到输出正常，这里也可以省略不写变量，因为默认情况为启用CGO状态

启用 CGO_ENABLED=0 的情况

root@ubuntu:/home/sxf/gotest# CGO_ENABLED=0 go build main.go
go: no Go source files

可以看到编译失败，验证了我们上面说的情况。

这里提示找不到go源文件，不清楚底层是如何判断这一情况的。

那么，如果我们一个程序里未调用cgo，在编译时指定 CGO_ENABLED 不同值话，又会发生什么呢？编译的二进制有何区别呢？

root@ubuntu:/home/sxf/gotest# CGO_ENABLED=1 go build -o cgo_main main.go
root@ubuntu:/home/sxf/gotest# CGO_ENABLED=0 go build -o no_cgo_main main.go
root@ubuntu:/home/sxf/gotest# ls -al
total 3804
drwxrwxr-x  2 sxf  sxf     4096 Nov 25 10:22 .
drwxr-x--- 47 sxf  sxf     4096 Nov 19 12:48 ..
-rwxr-xr-x  1 root root 1937311 Nov 25 10:22 cgo_main
-rw-rw-r--  1 sxf  sxf      119 Oct 29 09:07 go.mod
-rw-rw-r--  1 sxf  sxf      241 Oct 29 09:07 go.sum
-rw-rw-r--  1 sxf  sxf       72 Nov 25 10:21 main.go
-rwxr-xr-x  1 root root 1937311 Nov 25 10:22 no_cgo_main

可以看到两种情况都可能编译成功，且两者生成的二进制文件是完全一样的。由此总结出可以看出如果程序里未调用 cgo 的话，此变量值并没有影响的。

那么问题来了，为什么这么多项目里编译的时候都明确指定了此环境变量的值呢，主要是编译器在编译时会根据不同的情况使用不同的编译方法。 当CGO_ENABLED=1，进行编译时会将文件中引用libc的库（比如常用的net包），以动态链接的方式生成目标文件。 当CGO_ENABLED=0，进行编译时则会把在目标文件中未定义的符号（外部函数）一起链接到可执行文件中。

不论哪种方式，都可以使用静态连接编译

参考

• https://go.dev/blog/cgo
• https://pkg.go.dev/cmd/cgo
• https://johng.cn/cgo-enabled-affect-go-static-compile/
• https://github.com/golang/go/blob/a040ebeb98/src/cmd/cgo/doc.go
• https://www.jianshu.com/p/bc78c32db030