让团队一起使用官方的 Go 格式工具，不要重新发明轮子。
尝试减少代码复杂度。 这将帮助所有人使代码易于阅读。
// NOT BAD
if foo() {
// ...
} else if bar == baz {
// ...
} else {
// ...
}
// BETTER
switch {
case foo():
// ...
case bar == baz:
// ...
default:
// ...
}
当你在结构中看到 chan bool 的定义时，有时不容易理解如何使用该值，例如：
type Service struct {
deleteCh chan bool // what does this bool mean?
}
但是我们可以将其改为明确的 chan struct {} 来使其更清楚：我们不在乎值（它始终是 struct {}），我们关心可能发生的事件，例如：
type Service struct {
deleteCh chan struct{} // ok, if event than delete something.
}
你不需要将无类型的常量包装成类型，编译器会找出来。
另外最好将常量移到第一位：
// BAD
delay := time.Second * 60 * 24 * 60
// VERY BAD
delay := 60 * time.Second * 60 * 24
// GOOD
delay := 24 * 60 * 60 * time.Second
// BAD
var delayMillis int64 = 15000
// GOOD
var delay time.Duration = 15 * time.Second
// BAD
const (
foo = 1
bar = 2
message = "warn message"
)
// MOSTLY BAD
const foo = 1
const bar = 2
const message = "warn message"
// GOOD
const (
foo = 1
bar = 2
)
const message = "warn message"
这个模式也适用于 var。
defer func() {
err := ocp.Close()
if err != nil {
rerr = err
}
}()
package mAIn
type Status = int
type Format = int // remove `=` to have type safety
const A Status = 1
const B Format = 1
func main() {
println(A == B)
}
func f(a int, _ string) {}
func f(a int, b int, s string, p string)
func f(a, b int, s, p string)
var a []string
b := []string{}
fmt.Println(reflect.DeepEqual(a, []string{}))
fmt.Println(reflect.DeepEqual(b, []string{}))
// Output:
// false
// true
value := reflect.ValueOf(object)
kind := value.Kind()
if kind >= reflect.Chan && kind <= reflect.Slice {
// ...
}
func f1() {
var a, b struct{}
print(&a, "n", &b, "n") // Prints same address
fmt.Println(&a == &b) // Comparison returns false
}
func f2() {
var a, b struct{}
fmt.Printf("%pn%pn", &a, &b) // Again, same address
fmt.Println(&a == &b) // ...but the comparison returns true
}
const (
_ = iota
testvar // testvar 将是 int 类型
)
vs
type myType int
const (
_ myType = iota
testvar // testvar 将是 myType 类型
)
在某些时候，结构可能会改变，而你可能会错过这一点。因此，这可能会导致很难找到 bug。
// BAD
return res, json.Unmarshal(b, &res)
// GOOD
err := json.Unmarshal(b, &res)
return res, err
type Point struct {
X, Y float64
_ struct{} // to prevent unkeyed literals
}
对于 Point {X：1，Y：1} 都可以，但是对于 Point {1,1} 则会出现编译错误：
./file.go:1:11: too few values in Point literal
当在你所有的结构体中添加了 _ struct{} 后，使用 go vet 命令进行检查，（原来声明的方式）就会提示没有足够的参数。
type Point struct {
_ [0]func() // unexported, zero-width non-comparable field
X, Y float64
}
用 http.HandlerFunc 你仅需要一个 func，http.Handler 需要一个类型。
这可以提高代码可读性并明确函数结束时调用了什么。
用 json:"id,string" 代替
type Request struct {
ID int64 `json:"id,string"`
}
b := a[:0]
for _, x := range a {
if f(x) {
b = Append(b, x)
}
}
res, _ := client.Do(req)
io.Copy(ioutil.Discard, res.Body)
defer res.Body.Close()
ticker := time.NewTicker(1 * time.Second)
defer ticker.Stop()
func (entry Entry) MarshalJSON() ([]byte, error) {
buffer := bytes.NewBufferString("{")
first := true
for key, value := range entry {
jsonValue, err := json.Marshal(value)
if err != nil {
return nil, err
}
if !first {
buffer.WriteString(",")
}
first = false
buffer.WriteString(key + ":" + string(jsonValue))
}
buffer.WriteString("}")
return buffer.Bytes(), nil
}
// noescape hides a pointer from escape analysis. noescape is
// the identity function but escape analysis doesn't think the
// output depends on the input. noescape is inlined and currently
// compiles down to zero instructions.
//go:nosplit
func noescape(p unsafe.Pointer) unsafe.Pointer {
x := uintptr(p)
return unsafe.Pointer(x ^ 0)
}
for k := range m {
delete(m, k)
}
m = make(map[int]int)
func TestSomething(t *testing.T) {
if testing.Short() {
t.Skip("skipping test in short mode.")
}
}
if runtime.GOARM == "arm" {
t.Skip("this doesn't work under ARM")
}
go func() {
sigs := make(chan os.Signal, 1)
signal.Notify(sigs, syscall.SIGQUIT)
buf := make([]byte, 1<<20)
for {
<-sigs
stacklen := runtime.Stack(buf, true)
log.Printf("=== received SIGQUIT ===n*** goroutine dump...n%sn*** endn" , buf[:stacklen])
}
}()
var hits struct {
sync.Mutex
n int
}
hits.Lock()
hits.n++
hits.Unlock()
垃圾回收就是对程序中不再使用的内存资源进行自动回收的操作。
造成引用对象丢失的条件:
一个黑色的节点A新增了指向白色节点C的引用，并且白色节点C没有除了A之外的其他灰色节点的引用，或者存在但是在GC过程中被删除了。以上两个条件需要同时满足：满足条件1时说明节点A已扫描完毕，A指向C的引用无法再被扫描到；满足条件2时说明白色节点C无其他灰色节点的引用了，即扫描结束后会被忽略 。
写屏障破坏两个条件其一即可
满足强三色不变性：黑色节点不允许引用白色节点 当黑色节点新增了白色节点的引用时，将对应的白色节点改为灰色
满足弱三色不变性：黑色节点允许引用白色节点，但是该白色节点有其他灰色节点间接的引用（确保不会被遗漏） 当白色节点被删除了一个引用时，悲观地认为它一定会被一个黑色节点新增引用，所以将它置为灰色
协程的深入剖析
CSP 模型是“以通信的方式来共享内存”，不同于传统的多线程通过共享内存来通信。用于描述两个独立的并发实体通过共享的通讯 channel (管道)进行通信的并发模型。
M必须拥有P才可以执行G中的代码，P含有一个包含多个G的队列，P可以调度G交由M执行。
type hchan struct {
qcount uint // 队列中的总元素个数
dataqsiz uint // 环形队列大小，即可存放元素的个数
buf unsafe.Pointer // 环形队列指针
elemsize uint16 //每个元素的大小
closed uint32 //标识关闭状态
elemtype *_type // 元素类型
sendx uint // 发送索引，元素写入时存放到队列中的位置
recvx uint // 接收索引，元素从队列的该位置读出
recvq waitq // 等待读消息的goroutine队列
sendq waitq // 等待写消息的goroutine队列
lock mutex //互斥锁，chan不允许并发读写
}
向 channel 写数据:
若等待接收队列 recvq 不为空，则缓冲区中无数据或无缓冲区，将直接从 recvq 取出 G ，并把数据写入，最后把该 G 唤醒，结束发送过程。
若缓冲区中有空余位置，则将数据写入缓冲区，结束发送过程。
若缓冲区中没有空余位置，则将发送数据写入 G，将当前 G 加入 sendq ，进入睡眠，等待被读 goroutine 唤醒。
从 channel 读数据
若等待发送队列 sendq 不为空，且没有缓冲区，直接从 sendq 中取出 G ，把 G 中数据读出，最后把 G 唤醒，结束读取过程。
如果等待发送队列 sendq 不为空，说明缓冲区已满，从缓冲区中首部读出数据，把 G 中数据写入缓冲区尾部，把 G 唤醒，结束读取过程。
如果缓冲区中有数据，则从缓冲区取出数据，结束读取过程。
将当前 goroutine 加入 recvq ，进入睡眠，等待被写 goroutine 唤醒。
关闭 channel
1.关闭 channel 时会将 recvq 中的 G 全部唤醒，本该写入 G 的数据位置为 nil。将 sendq 中的 G 全部唤醒，但是这些 G 会 panic。
panic 出现的场景还有：
// 无缓冲的channel由于没有缓冲发送和接收需要同步
ch := make(chan int)
//有缓冲channel不要求发送和接收操作同步
ch := make(chan int, 2)
channel 无缓冲时，发送阻塞直到数据被接收，接收阻塞直到读到数据；channel有缓冲时，当缓冲满时发送阻塞，当缓冲空时接收阻塞。
Context（上下文）是Golang应用开发常用的并发控制技术 ，它可以控制一组呈树状结构的goroutine，每个goroutine拥有相同的上下文。Context 是并发安全的，主要是用于控制多个协程之间的协作、取消操作。
Context 只定义了接口，凡是实现该接口的类都可称为是一种 context。
并发控制神器之Context
type Context interface {
Deadline() (deadline time.Time, ok bool)
Done() <-chan struct{}
Err() error
Value(key interface{}) interface{}
}
并发控制，同步原语 sync 包
资源竞争，就是在程序中，同一块内存同时被多个 goroutine 访问。我们使用 go build、go run、go test 命令时，添加 -race 标识可以检查代码中是否存在资源竞争。
解决这个问题，我们可以给资源进行加锁，让其在同一时刻只能被一个协程来操作。
面试官问我go逃逸场景有哪些，我？？？
「逃逸分析」就是程序运行时内存的分配位置(栈或堆)，是由编译器来确定的。堆适合不可预知大小的内存分配。但是为此付出的代价是分配速度较慢，而且会形成内存碎片。
逃逸场景：
Go 中 Goroutine 可以通过 Channel 进行安全读写共享变量。
用new还是make？到底该如何选择？
首先Go的JSON 标准库对 nil slice 和 空 slice 的处理是不一致。
并发掌握，goroutine和channel声明与使用！
****协程: 协程是一种用户态的轻量级线程，协程的调度完全是由用户来控制的。协程拥有自己的寄存器上下文和栈。协程调度切换时，将寄存器上下文和栈保存到其他地方，在切回来的时候，恢复先前保存的寄存器上下文和栈，直接操作栈则基本没有内核切换的开销，可以不加锁的访问全局变量，所以上下文的切换非常快。
通常小对象过多会导致GC三色法消耗过多的GPU。优化思路是，减少对象分配。
Channel 可以理解是一个先进先出的队列，通过管道进行通信,发送一个数据到Channel和从Channel接收一个数据都是原子性的。不要通过共享内存来通信，而是通过通信来共享内存，前者就是传统的加锁，后者就是Channel。设计Channel的主要目的就是在多任务间传递数据的，本身就是安全的。
主动触发(手动触发)，通过调用 runtime.GC 来触发GC，此调用阻塞式地等待当前GC运行完毕。
被动触发，分为两种方式：
Channel是异步进行的, channel存在3种状态：
|
操作 |
一个零值nil通道 |
一个非零值但已关闭的通道 |
一个非零值且尚未关闭的通道 |
|
关闭 |
产生恐慌 |
产生恐慌 |
成功关闭 |
|
发送数据 |
永久阻塞 |
产生恐慌 |
阻塞或者成功发送 |
|
接收数据 |
永久阻塞 |
永不阻塞 |
阻塞或者成功接收 |
使用sync.WaitGroup。WaitGroup，就是用来等待一组操作完成的。WaitGroup内部实现了一个计数器，用来记录未完成的操作个数。Add()用来添加计数；Done()用来在操作结束时调用，使计数减一；Wait()用来等待所有的操作结束，即计数变为0，该函数会在计数不为0时等待，在计数为0时立即返回。
slice 实现原理
在使用 append 向 slice 追加元素时，若 slice 空间不足则会发生扩容，扩容会重新分配一块更大的内存，将原 slice 拷贝到新 slice ，然后返回新 slice。扩容后再将数据追加进去。
扩容操作只对容量，扩容后的 slice 长度不变，容量变化规则如下：
Go中map如果要实现顺序读取的话，可以先把map中的key，通过sort包排序。
究竟在什么情况下才使用指针？
参数传递中，值、引用及指针之间的区别！
方法的接收者:
但是接口的实现，值类型接收者和指针类型接收者不一样：
通常我们使用指针作为方法的接收者的理由：
Goroutine 需要维护执行用户代码的上下文信息，在运行过程中需要消耗一定的内存来保存这类信息，如果一个程序持续不断地产生新的 goroutine，且不结束已经创建的 goroutine 并复用这部分内存，就会造成内存泄漏的现象。
可以通过Go自带的工具pprof或者使用Gops去检测诊断当前在系统上运行的Go进程的占用的资源。
Go中两个Nil可能不相等。
接口(interface) 是对非接口值(例如指针，struct等)的封装，内部实现包含 2 个字段，类型 T 和 值 V。一个接口等于 nil，当且仅当 T 和 V 处于 unset 状态（T=nil，V is unset）。
两个接口值比较时，会先比较 T，再比较 V。接口值与非接口值比较时，会先将非接口值尝试转换为接口值，再比较。
func main() {
var p *int = nil
var i interface{} = p
fmt.Println(i == p) // true
fmt.Println(p == nil) // true
fmt.Println(i == nil) // false
}
CPU 访问内存时，并不是逐个字节访问，而是以字长（word size）为单位访问。比如 32 位的 CPU ，字长为 4 字节，那么 CPU 访问内存的单位也是 4 字节。
CPU 始终以字长访问内存，如果不进行内存对齐，很可能增加 CPU 访问内存的次数，例如：
变量 a、b 各占据 3 字节的空间，内存对齐后，a、b 占据 4 字节空间，CPU 读取 b 变量的值只需要进行一次内存访问。如果不进行内存对齐，CPU 读取 b 变量的值需要进行 2 次内存访问。第一次访问得到 b 变量的第 1 个字节，第二次访问得到 b 变量的后两个字节。
也可以看到，内存对齐对实现变量的原子性操作也是有好处的，每次内存访问是原子的，如果变量的大小不超过字长，那么内存对齐后，对该变量的访问就是原子的，这个特性在并发场景下至关重要。
简言之：合理的内存对齐可以提高内存读写的性能，并且便于实现变量操作的原子性。
reflect.TypeOf(a).Kind() == reflect.TypeOf(b).Kind()
reflect.DeepEqual(a, b interface{})
reflect.ValueOf(a).Elem().Set(reflect.ValueOf(b))
package main
import "fmt"
type student struct {
id int32
name string
}
func main() {
a := &student{id: 1, name: "微客鸟窝"}
fmt.Printf("a=%v n", a) // a=&{1 微客鸟窝}
fmt.Printf("a=%+v n", a) // a=&{id:1 name:微客鸟窝}
fmt.Printf("a=%#v n", a) // a=&main.student{id:1, name:"微客鸟窝"}
}
Go语言的字符有以下两种：
package main
import "fmt"
func main() {
var str = "hello 你好" //思考下 len(str) 的长度是多少？
//golang中string底层是通过byte数组实现的，直接求len 实际是在按字节长度计算
//所以一个汉字占3个字节算了3个长度
fmt.Println("len(str):", len(str)) // len(str): 12
//通过rune类型处理unicode字符
fmt.Println("rune:", len([]rune(str))) //rune: 8
}
可以使用 unsafe.Sizeof 计算出一个数据类型实例需要占用的字节数:
package main
import (
"fmt"
"unsafe"
)
func main() {
fmt.Println(unsafe.Sizeof(struct{}{})) //0
}
空结构体 struct{} 实例不占据任何的内存空间。
因为空结构体不占据内存空间，因此被广泛作为各种场景下的占位符使用。
type Set map[string]struct{}
func (s Set) Has(key string) bool {
_, ok := s[key]
return ok
}
func (s Set) Add(key string) {
s[key] = struct{}{}
}
func (s Set) Delete(key string) {
delete(s, key)
}
func main() {
s := make(Set)
s.Add("Tom")
s.Add("Sam")
fmt.Println(s.Has("Tom"))
fmt.Println(s.Has("Jack"))
}
不发送数据的信道(channel)
使用 channel 不需要发送任何的数据，只用来通知子协程(goroutine)执行任务，或只用来控制协程并发度。
func worker(ch chan struct{}) {
<-ch
fmt.Println("do something")
close(ch)
}
func main() {
ch := make(chan struct{})
go worker(ch)
ch <- struct{}{}
}
结构体只包含方法，不包含任何的字段
type Door struct{}
func (d Door) Open() {
fmt.Println("Open the door")
}
func (d Door) Close() {
fmt.Println("Close the door")
}
京公网安备 11010802035086号