Golang 面试题

// new - 分配内存，返回指针，零值初始化
p := new(int)       // *int，值为 0
s := new([]int)     // *[]int，值为 nil

// make - 分配并初始化内部结构
slice := make([]int, 0, 10)     // []int，已初始化
m := make(map[string]int)       // map，已初始化
ch := make(chan int, 5)         // chan，已初始化

type _defer struct {
    siz     int32    // 参数大小
    started bool
    sp      uintptr  // 栈指针
    pc      uintptr  // 程序计数器
    fn      *funcval // 延迟函数
    link    *_defer  // 链表指针
}

// 情况一：返回值是匿名变量
func f1() int {
    x := 5
    defer func() { x++ }()
    return x  // 返回 5（x 的副本）
}

// 情况二：返回值是命名变量
func f2() (x int) {
    defer func() { x++ }()
    return 5  // 返回 6（defer 修改了命名返回值）
}

select {
case msg := <-ch1:
    // 处理 ch1
case ch2 <- x:
    // 发送到 ch2
case <-time.After(time.Second):
    // 超时处理
default:
    // 非阻塞（所有 case 不满足时执行）
}

type Person struct {
    Name string
    Age  int
}
p1 := Person{"Tom", 18}
p2 := Person{"Tom", 18}
fmt.Println(p1 == p2)  // true ✅

type Data struct {
    Values []int  // 包含 slice
}
// d1 == d2  // 编译错误！❌

func createUser() *User {
    u := User{Name: "Tom"}  // 逃逸到堆
    return &u               // 安全返回
}

var p *int = nil
var i interface{} = p
fmt.Println(i == nil)  // false! ❌

type eface struct {
    _type *_type         // 类型：*int（非 nil）
    data  unsafe.Pointer // 值：nil
}

type error interface {
    Error() string
}

// 1. 直接返回
if err != nil {
    return err
}

// 2. 包装错误（Go 1.13+）
if err != nil {
    return fmt.Errorf("读取配置失败: %w", err)
}

// 3. 错误判断
if errors.Is(err, os.ErrNotExist) {
    // 处理文件不存在
}

// 4. 类型断言
var pathErr *os.PathError
if errors.As(err, &pathErr) {
    fmt.Println(pathErr.Path)
}

// 方法一：实现 error 接口
type MyError struct {
    Code    int
    Message string
}

func (e *MyError) Error() string {
    return fmt.Sprintf("[%d] %s", e.Code, e.Message)
}

// 方法二：使用 errors.New
var ErrNotFound = errors.New("not found")

// 方法三：使用 fmt.Errorf
err := fmt.Errorf("user %d not found", userID)

// 触发 panic
panic("something went wrong")

// 常见触发场景
arr[100]          // 数组越界
nil.Method()      // nil 指针调用方法
close(closedChan) // 重复关闭 channel

func safeCall() {
    defer func() {
        if r := recover(); r != nil {
            log.Printf("Recovered: %v", r)
            // 打印堆栈
            debug.PrintStack()
        }
    }()
    
    // 可能 panic 的代码
    riskyOperation()
}

func main() {
    defer fmt.Println("1")
    defer fmt.Println("2")
    
    defer func() {
        if r := recover(); r != nil {
            fmt.Println("Recovered:", r)
        }
    }()
    
    defer fmt.Println("3")
    
    panic("error!")
    
    defer fmt.Println("4")  // 不会执行
}

// 输出：
// 3
// Recovered: error!
// 2
// 1

type stringStruct struct {
    str unsafe.Pointer  // 指向底层字节数组
    len int             // 字符串长度（字节数）
}

type slice struct {
    array unsafe.Pointer  // 指向底层数组
    len   int             // 当前长度
    cap   int             // 容量
}

if oldCap < 256 {
    newCap = oldCap * 2  // 翻倍
} else {
    newCap = oldCap + (oldCap + 3*256) / 4  // 约 1.25 倍增长
}

var nilSlice []int          // nil slice: nil, len=0, cap=0
emptySlice := []int{}       // 空 slice: 非 nil, len=0, cap=0
emptySlice2 := make([]int, 0) // 空 slice: 非 nil, len=0, cap=0

func modify(s []int) {
    s[0] = 100       // ✅ 会修改原切片
    s = append(s, 4) // ❌ 不会影响原切片的 len
}

type hmap struct {
    count     int            // 元素个数
    B         uint8          // bucket 数量 = 2^B
    hash0     uint32         // 哈希种子（随机化）
    buckets   unsafe.Pointer // bucket 数组
    oldbuckets unsafe.Pointer // 扩容时的旧 bucket
}

// 方法：收集 key 排序
keys := make([]string, 0, len(m))
for k := range m {
    keys = append(keys, k)
}
sort.Strings(keys)
for _, k := range keys {
    fmt.Println(k, m[k])
}

type eface struct {
    _type *_type         // 类型信息
    data  unsafe.Pointer // 数据指针
}

type iface struct {
    tab  *itab           // 类型和方法表
    data unsafe.Pointer  // 数据指针
}

type hchan struct {
    qcount   uint           // 当前元素数量
    dataqsiz uint           // 缓冲区大小
    buf      unsafe.Pointer // 环形队列指针
    lock     mutex          // 互斥锁（关键！）
    sendq    waitq          // 发送等待队列
    recvq    waitq          // 接收等待队列
}

ch := make(chan int)  // 无缓冲

go func() {
    ch <- 42  // 阻塞直到有接收者
}()

val := <-ch  // 阻塞直到有发送者

type Mutex struct {
    state int32   // 锁状态（locked、woken、starving、waiter count）
    sema  uint32  // 信号量
}

// 如果 addr 的值等于 old，则替换为 new
func CompareAndSwapInt64(addr *int64, old, new int64) bool

var counter int64

// CAS 自旋
for {
    old := atomic.LoadInt64(&counter)
    if atomic.CompareAndSwapInt64(&counter, old, old+1) {
        break
    }
}

go run -race main.go    # 运行时检测
go test -race ./...     # 测试时检测

jobs := make(chan int, 100)
for w := 0; w < 10; w++ {
    go worker(jobs)  // 固定 worker 数量
}

func gen() <-chan int { ... }
func sq(in <-chan int) <-chan int { ... }

sem := make(chan struct{}, 10)  // 最多 10 个并发

sem := make(chan struct{}, 10)  // 最多 10 个

for i := 0; i < 100; i++ {
    sem <- struct{}{}  // 获取
    go func() {
        defer func() { <-sem }()  // 释放
        // work...
    }()
}

// 方法一：runtime
fmt.Println(runtime.NumGoroutine())

// 方法二：pprof
import _ "net/http/pprof"
go http.ListenAndServe(":6060", nil)
// 访问 http://localhost:6060/debug/pprof/goroutine

var wg sync.WaitGroup
for i := 0; i < 10; i++ {
    wg.Add(1)
    go func() {
        defer wg.Done()
        // work...
    }()
}
wg.Wait()  // 等待所有完成

g, ctx := errgroup.WithContext(ctx)
g.Go(func() error { ... })
err := g.Wait()

ctx, cancel := context.WithCancel(context.Background())
go func(ctx context.Context) {
    for {
        select {
        case <-ctx.Done():
            return  // 退出
        default:
            // 工作...
        }
    }
}(ctx)
cancel()  // 发送取消信号

runtime.Goexit()  // 立即终止当前 goroutine

// 1. runtime
fmt.Println(runtime.NumGoroutine())

// 2. pprof
go tool pprof http://localhost:6060/debug/pprof/goroutine

// 3. goleak（测试用）
func TestNoLeak(t *testing.T) {
    defer goleak.VerifyNone(t)
    // test code
}

ticker := time.NewTicker(time.Second)
defer ticker.Stop()  // 必须停止！

mcache（每个 P 一个，无锁）
    ↓
mcentral（每个 size class 一个，有锁）
    ↓
mheap（全局唯一，管理所有内存）

go build -gcflags="-m" main.go

func escape() *int {
    x := 42
    return &x  // x 逃逸到堆
}

GOGC=100   # 默认值，堆内存增长 100% 触发 GC
GOGC=200   # 降低 GC 频率
GOGC=off   # 关闭 GC（不推荐）

Mark Setup (STW 1)    ~10-30μs   开启写屏障
Concurrent Mark                   后台标记
Mark Termination (STW 2) ~60-90μs 关闭写屏障
Concurrent Sweep                  清理

type Handler interface {
    ServeHTTP(ResponseWriter, *Request)
}

type ServeMux struct {
    mu    sync.RWMutex
    m     map[string]muxEntry
}

var pool = sync.Pool{
    New: func() interface{} {
        return new(bytes.Buffer)
    },
}

buf := pool.Get().(*bytes.Buffer)
buf.Reset()
// 使用 buf...
pool.Put(buf)

type Once struct {
    done uint32
    m    Mutex
}

func (o *Once) Do(f func()) {
    if atomic.LoadUint32(&o.done) == 1 {
        return  // 快速路径
    }
    o.m.Lock()
    defer o.m.Unlock()
    if o.done == 0 {
        defer atomic.StoreUint32(&o.done, 1)
        f()
    }
}

var (
    instance *Singleton
    once     sync.Once
)

func GetInstance() *Singleton {
    once.Do(func() {
        instance = &Singleton{}
    })
    return instance
}

import _ "net/http/pprof"

go http.ListenAndServe(":6060", nil)

# CPU 分析
go tool pprof http://localhost:6060/debug/pprof/profile?seconds=30

# 内存分析
go tool pprof http://localhost:6060/debug/pprof/heap

# Goroutine 分析
go tool pprof http://localhost:6060/debug/pprof/goroutine

# 常用命令
top, list, web, svg

type Context struct {
    handlers HandlersChain  // []HandlerFunc
    index    int8           // 当前执行的 handler 索引
}

func (c *Context) Next() {
    c.index++
    for c.index < int8(len(c.handlers)) {
        c.handlers[c.index](c)
        c.index++
    }
}

请求 → Middleware1 → Middleware2 → Handler → Middleware2 → Middleware1 → 响应

// 创建前
func (u *User) BeforeCreate(tx *gorm.DB) error {
    u.Password = hashPassword(u.Password)
    return nil
}

// 更新前
func (u *User) BeforeUpdate(tx *gorm.DB) error {
    if tx.Statement.Changed("Password") {
        u.Password = hashPassword(u.Password)
    }
    return nil
}

// 加锁
func TryLock(ctx context.Context, key, value string, ttl time.Duration) bool {
    ok, _ := rdb.SetNX(ctx, key, value, ttl).Result()
    return ok
}

// 解锁（Lua 保证原子性）
func Unlock(ctx context.Context, key, value string) bool {
    script := redis.NewScript(`
        if redis.call('get', KEYS[1]) == ARGV[1] then
            return redis.call('del', KEYS[1])
        end
        return 0
    `)
    result, _ := script.Run(ctx, rdb, []string{key}, value).Int()
    return result == 1
}

import "github.com/sony/gobreaker"

cb := gobreaker.NewCircuitBreaker(gobreaker.Settings{
    Name:        "my-service",
    MaxRequests: 3,
    Timeout:     30 * time.Second,
    ReadyToTrip: func(counts gobreaker.Counts) bool {
        failureRatio := float64(counts.TotalFailures) / float64(counts.Requests)
        return counts.Requests >= 3 && failureRatio >= 0.6
    },
})

result, err := cb.Execute(func() (interface{}, error) {
    return doRequest()
})

func processOrder(orderID string) error {
    if processed, _ := redis.Get("processed:" + orderID); processed != "" {
        return nil  // 已处理
    }
    
    if err := doProcess(orderID); err != nil {
        return err
    }
    
    redis.Set("processed:"+orderID, "1", 24*time.Hour)
    return nil
}

// Gin 的 Engine 实现了 http.Handler 接口
type Engine struct {
    // ...
}

func (engine *Engine) ServeHTTP(w http.ResponseWriter, req *http.Request) {
    // 处理请求
}

// 可以作为 http.Handler 使用
http.ListenAndServe(":8080", engine)

请求 → M1(前) → M2(前) → M3(前) → Handler
响应 ← M1(后) ← M2(后) ← M3(后) ←┘

func Logger() gin.HandlerFunc {
    return func(c *gin.Context) {
        start := time.Now()
        
        c.Next()  // 执行后续处理
        
        latency := time.Since(start)
        log.Printf("耗时: %v", latency)
    }
}

func AuthMiddleware() gin.HandlerFunc {
    return func(c *gin.Context) {
        token := c.GetHeader("Authorization")
        
        // 1. 检查 Token 是否存在
        if token == "" {
            c.AbortWithStatusJSON(401, gin.H{"error": "未授权"})
            return
        }
        
        // 2. 验证 Token
        claims, err := jwt.ParseToken(token)
        if err != nil {
            c.AbortWithStatusJSON(401, gin.H{"error": "Token 无效"})
            return
        }
        
        // 3. 将用户信息存入 Context
        c.Set("userID", claims.UserID)
        c.Set("role", claims.Role)
        
        c.Next()
    }
}

r := gin.Default()  // 包含 Logger 和 Recovery

// 手动添加
r.Use(gin.Recovery())

// 自定义 Recovery
r.Use(gin.CustomRecovery(func(c *gin.Context, err interface{}) {
    // 记录日志
    log.Printf("Panic: %v", err)
    
    // 返回错误响应
    c.AbortWithStatusJSON(500, gin.H{
        "error": "服务器内部错误",
    })
}))

1. 请求进入 → net/http 接收
2. Engine.ServeHTTP() → 从连接池获取 Context
3. 路由匹配 → 基数树查找
4. 执行中间件链 → handlers[0:n]
5. 参数绑定 → Query/JSON/Form
6. 业务处理 → Controller
7. 响应写入 → c.JSON() / c.String()
8. Context 回收 → 放回连接池

type CreateUserReq struct {
    Username string `json:"username" binding:"required,min=3,max=20"`
    Email    string `json:"email" binding:"required,email"`
    Age      int    `json:"age" binding:"gte=18,lte=100"`
    Password string `json:"password" binding:"required,min=6"`
}

func CreateUser(c *gin.Context) {
    var req CreateUserReq
    
    if err := c.ShouldBindJSON(&req); err != nil {
        // 自定义错误处理
        c.JSON(400, gin.H{
            "error": translateError(err),
        })
        return
    }
    
    // 业务逻辑...
}

import "golang.org/x/time/rate"

limiter := rate.NewLimiter(100, 10)  // 每秒 100 个，突发 10 个

if !limiter.Allow() {
    c.JSON(429, gin.H{"error": "请求过于频繁"})
    return
}

func GetUserInfo(userID string) (*User, error) {
    // 1. 尝试从缓存获取
    if user, err := cache.Get(userID); err == nil {
        return user, nil
    }
    
    // 2. 熔断器检查
    if circuitBreaker.IsOpen() {
        // 降级：返回默认数据
        return getDefaultUser(userID), nil
    }
    
    // 3. 调用服务
    user, err := userService.Get(userID)
    if err != nil {
        circuitBreaker.RecordFailure()
        // 降级：返回缓存的旧数据
        return cache.GetStale(userID), nil
    }
    
    return user, nil
}

func healthCheck(c *gin.Context) {
    // 检查依赖服务
    if err := db.Ping(); err != nil {
        c.JSON(503, gin.H{"status": "unhealthy"})
        return
    }
    if err := redis.Ping(); err != nil {
        c.JSON(503, gin.H{"status": "unhealthy"})
        return
    }
    c.JSON(200, gin.H{"status": "healthy"})
}

import _ "net/http/pprof"

go func() {
    http.ListenAndServe(":6060", nil)
}()

# CPU 分析
go tool pprof http://localhost:6060/debug/pprof/profile?seconds=30

# 内存分析
go tool pprof http://localhost:6060/debug/pprof/heap

# Goroutine 分析
go tool pprof http://localhost:6060/debug/pprof/goroutine

# 阻塞分析
go tool pprof http://localhost:6060/debug/pprof/block

# 常用命令
(pprof) top         # 热点函数
(pprof) list func   # 查看函数代码
(pprof) web         # 生成图形

# 1. 找到 Go 进程
ps aux | grep myapp

# 2. 采集 CPU Profile
curl http://localhost:6060/debug/pprof/profile?seconds=30 > cpu.pprof

# 3. 分析
go tool pprof cpu.pprof
(pprof) top 20
(pprof) web

# 采集堆内存
curl http://localhost:6060/debug/pprof/heap > heap.pprof

# 分析
go tool pprof heap.pprof
(pprof) top -inuse_space    # 当前使用
(pprof) top -alloc_space    # 累计分配

go tool pprof -http=:8080 cpu.pprof

import jsoniter "github.com/json-iterator/go"

var json = jsoniter.ConfigCompatibleWithStandardLibrary
json.Marshal(obj)
json.Unmarshal(data, &obj)

# 构建阶段
FROM golang:1.21-alpine AS builder
WORKDIR /app
COPY go.mod go.sum ./
RUN go mod download
COPY . .
RUN CGO_ENABLED=0 go build -o main .

# 运行阶段
FROM alpine:latest
RUN apk --no-cache add ca-certificates
WORKDIR /app
COPY --from=builder /app/main .
EXPOSE 8080
CMD ["./main"]

# Service（集群内部）
apiVersion: v1
kind: Service
metadata:
  name: my-service
spec:
  selector:
    app: myapp
  ports:
    - port: 80
      targetPort: 8080
---
# Ingress（对外）
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: my-ingress
spec:
  rules:
    - host: api.example.com
      http:
        paths:
          - path: /
            pathType: Prefix
            backend:
              service:
                name: my-service
                port:
                  number: 80

apiVersion: apps/v1
kind: Deployment
metadata:
  name: myapp
spec:
  replicas: 3
  strategy:
    type: RollingUpdate
    rollingUpdate:
      maxSurge: 1        # 最多多 1 个 Pod
      maxUnavailable: 0  # 最少可用数

kubectl set image deployment/myapp myapp=myapp:v2
kubectl rollout status deployment/myapp
kubectl rollout undo deployment/myapp  # 回滚

project/
├── cmd/                # 入口
│   └── server/
│       └── main.go
├── internal/           # 私有代码
│   ├── handler/        # HTTP 处理
│   ├── service/        # 业务逻辑
│   ├── repository/     # 数据访问
│   └── model/          # 数据模型
├── pkg/                # 可导出的公共包
├── api/                # API 定义（proto/swagger）
├── configs/            # 配置文件
├── scripts/            # 脚本
├── test/               # 测试
├── go.mod
└── Makefile

// user_service_test.go
func TestCreateUser(t *testing.T) {
    // Arrange
    mockRepo := &MockUserRepo{}
    service := NewUserService(mockRepo)
    
    mockRepo.On("Create", mock.Anything).Return(nil)
    
    // Act
    err := service.Create(&User{Name: "test"})
    
    // Assert
    assert.NoError(t, err)
    mockRepo.AssertExpectations(t)
}

// 表驱动测试
func TestAdd(t *testing.T) {
    tests := []struct {
        name     string
        a, b     int
        expected int
    }{
        {"positive", 1, 2, 3},
        {"negative", -1, -2, -3},
        {"zero", 0, 0, 0},
    }
    
    for _, tt := range tests {
        t.Run(tt.name, func(t *testing.T) {
            result := Add(tt.a, tt.b)
            assert.Equal(t, tt.expected, result)
        })
    }
}

// 使用 testify/mock
type MockUserRepo struct {
    mock.Mock
}

func (m *MockUserRepo) GetByID(id int64) (*User, error) {
    args := m.Called(id)
    return args.Get(0).(*User), args.Error(1)
}

// 测试中使用
mockRepo.On("GetByID", int64(1)).Return(&User{ID: 1}, nil)