Go 社招基础：缓存、多态、协程池与并发读写

package main

import (
    "fmt"
    "sync"
)

// Cache 线程安全的简单缓存
type Cache struct {
    mu    sync.RWMutex
    store map[string]string
}

// NewCache 创建缓存
func NewCache() *Cache {
    return &Cache{
        store: make(map[string]string),
    }
}

// Set 写入缓存
func (c *Cache) Set(key, value string) {
    // 步骤1：写锁，保证同一时刻只有一个 goroutine 写入
    c.mu.Lock()
    defer c.mu.Unlock()
    c.store[key] = value
}

// Get 读取缓存
func (c *Cache) Get(key string) (string, bool) {
    // 步骤2：读锁，允许多个 goroutine 同时读
    c.mu.RLock()
    defer c.mu.RUnlock()
    val, ok := c.store[key]
    return val, ok
}

// Delete 删除缓存
func (c *Cache) Delete(key string) {
    c.mu.Lock()
    defer c.mu.Unlock()
    delete(c.store, key)
}

func main() {
    cache := NewCache()

    // 步骤3：并发写入
    var wg sync.WaitGroup
    for i := 0; i < 10; i++ {
        wg.Add(1)
        go func(n int) {
            defer wg.Done()
            cache.Set(fmt.Sprintf("key%d", n), fmt.Sprintf("value%d", n))
        }(i)
    }
    wg.Wait()

    // 步骤4：并发读取
    for i := 0; i < 10; i++ {
        if val, ok := cache.Get(fmt.Sprintf("key%d", i)); ok {
            fmt.Printf("key%d = %s\n", i, val)
        }
    }
}

package main

import (
    "fmt"
    "sync"
    "time"
)

// cacheItem 缓存条目
type cacheItem struct {
    value    string
    expireAt time.Time
}

// TTLCache 带 TTL 的线程安全缓存
type TTLCache struct {
    mu    sync.RWMutex
    store map[string]*cacheItem
}

func NewTTLCache() *TTLCache {
    return &TTLCache{
        store: make(map[string]*cacheItem),
    }
}

// Set 写入缓存，ttl 为存活时间
func (c *TTLCache) Set(key, value string, ttl time.Duration) {
    c.mu.Lock()
    defer c.mu.Unlock()

    // 步骤1：设置过期时间
    c.store[key] = &cacheItem{
        value:    value,
        expireAt: time.Now().Add(ttl),
    }

    // 步骤2：启动定时器，到期后自动删除
    time.AfterFunc(ttl, func() {
        c.mu.Lock()
        delete(c.store, key)
        c.mu.Unlock()
    })
}

// Get 读取缓存，如果已过期返回 false
func (c *TTLCache) Get(key string) (string, bool) {
    c.mu.RLock()
    defer c.mu.RUnlock()

    item, ok := c.store[key]
    if !ok {
        return "", false
    }

    // 步骤3：检查是否过期
    if time.Now().After(item.expireAt) {
        return "", false
    }
    return item.value, true
}

func main() {
    cache := NewTTLCache()

    // 步骤4：写入 TTL 为 2 秒的缓存
    cache.Set("name", "Alice", 2*time.Second)

    // 步骤5：立即读取，命中
    if val, ok := cache.Get("name"); ok {
        fmt.Println("before expiry:", val)
    }

    // 步骤6：等待 3 秒后读取，未命中
    time.Sleep(3 * time.Second)
    if _, ok := cache.Get("name"); !ok {
        fmt.Println("after expiry: key not found")
    }
}

package main

import "fmt"

// 步骤1：定义接口，规定Animal必须实现的方法
type Animal interface {
    Speak() string
    Name() string
}

// 步骤2：Dog 实现Animal接口（隐式实现，无需implements关键字）
type Dog struct {
    name string
}

func (d Dog) Speak() string {
    return "Woof!"
}

func (d Dog) Name() string {
    return d.name
}

// 步骤3：Cat 实现Animal接口
type Cat struct {
    name string
}

func (c Cat) Speak() string {
    return "Meow!"
}

func (c Cat) Name() string {
    return c.name
}

// 步骤4：Cow 实现Animal接口
type Cow struct {
    name string
}

func (c Cow) Speak() string {
    return "Moo!"
}

func (c Cow) Name() string {
    return c.name
}

func main() {
    // 步骤5：将不同类型放入同一个 interface 切片
    animals := []Animal{
        Dog{name: "Buddy"},
        Cat{name: "Whiskers"},
        Cow{name: "Bessie"},
    }

    // 步骤6：通过接口统一调用，实现多态
    for _, animal := range animals {
        fmt.Printf("%s says: %s\n", animal.Name(), animal.Speak())
    }
}

// Redis 分布式锁的 Go 调用逻辑（伪代码，展示调用模式）
// 实际使用需要引入 redis 客户端库如 github.com/redis/go-redis/v9
func acquireLock(rdb RedisClient, key, token string, ttl time.Duration) bool {
    // 步骤3：SET key token NX EX ttl
    ok, err := rdb.SetNX(context.Background(), key, token, ttl).Result()
    return err == nil && ok
}

func releaseLock(rdb RedisClient, key, token string) bool {
    // 步骤4：Lua 脚本原子性释放
    script := "if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del', KEYS[1]) else return 0 end"
    result, err := rdb.Eval(context.Background(), script, []string{key}, token).Result()
    return err == nil && result.(int64) == 1
}

-- 步骤1：查询时获取当前 version
SELECT id, stock, version FROM products WHERE id = 1001;
-- 假设查到 stock=10, version=3

-- 步骤2：更新时带上 version 条件，CAS 思想
UPDATE products
SET stock = stock - 1, version = version + 1
WHERE id = 1001 AND version = 3;
-- 如果 affected_rows = 0，说明被别人改过，需要重试

-- 步骤1：事务中加排他锁，其他事务必须等待
BEGIN;
SELECT * FROM products WHERE id = 1001 FOR UPDATE;
-- 此时其他事务的 SELECT FOR UPDATE 会被阻塞

-- 步骤2：安全地更新数据
UPDATE products SET stock = stock - 1 WHERE id = 1001;

-- 步骤3：提交事务，释放锁
COMMIT;

package main

import (
    "container/list"
    "fmt"
)

// entry LRU 缓存条目
type entry struct {
    key   string
    value string
}

// LRU LRU 缓存
type LRU struct {
    capacity int                   // 最大容量
    cache    map[string]*list.Element // key 到链表节点的映射
    list     *list.List            // 双向链表，front 是最近使用
}

// NewLRU 创建 LRU 缓存
func NewLRU(capacity int) *LRU {
    return &LRU{
        capacity: capacity,
        cache:    make(map[string]*list.Element),
        list:     list.New(),
    }
}

// Get 读取缓存，命中则移到队首
func (l *LRU) Get(key string) (string, bool) {
    if elem, ok := l.cache[key]; ok {
        // 步骤1：移到队首（标记为最近使用）
        l.list.MoveToFront(elem)
        return elem.Value.(*entry).value, true
    }
    return "", false
}

// Put 写入缓存
func (l *LRU) Put(key, value string) {
    if elem, ok := l.cache[key]; ok {
        // 步骤2：key 已存在，更新值并移到队首
        l.list.MoveToFront(elem)
        elem.Value.(*entry).value = value
        return
    }

    // 步骤3：新 key，创建条目放在队首
    elem := l.list.PushFront(&entry{key: key, value: value})
    l.cache[key] = elem

    // 步骤4：超过容量，淘汰队尾（最久未使用）
    if l.list.Len() > l.capacity {
        oldest := l.list.Back()
        if oldest != nil {
            l.list.Remove(oldest)
            delete(l.cache, oldest.Value.(*entry).key)
        }
    }
}

// Remove 主动删除指定 key
func (l *LRU) Remove(key string) bool {
    if elem, ok := l.cache[key]; ok {
        // 步骤5：从链表和 map 中同时删除
        l.list.Remove(elem)
        delete(l.cache, key)
        return true
    }
    return false
}

// Len 返回当前缓存大小
func (l *LRU) Len() int {
    return l.list.Len()
}

func main() {
    // 步骤6：创建容量为 3 的 LRU 缓存
    lru := NewLRU(3)

    // 步骤7：写入 3 个 key
    lru.Put("a", "value-a")
    lru.Put("b", "value-b")
    lru.Put("c", "value-c")

    // 步骤8：访问 a，使 a 移到队首（b 变成最久未使用）
    lru.Get("a")

    // 步骤9：写入 d，容量超限，淘汰队尾的 b
    lru.Put("d", "value-d")

    // 步骤10：验证结果
    fmt.Println("a:", lru.Get("a")) // 命中
    fmt.Println("b:", lru.Get("b")) // 未命中（已被淘汰）
    fmt.Println("c:", lru.Get("c")) // 命中
    fmt.Println("d:", lru.Get("d")) // 命中
    fmt.Println("len:", lru.Len())  // 3
}

// 错误写法：func 后面直接换行写语句，缺 {
func main()
    fmt.Println("hello world")
// 编译报错：syntax error: unexpected semicolon or newline before {

// 正确写法：补上 {
func main() {
    fmt.Println("hello world") // works
}

// 错误写法：import 出现在 func main 体内
func main() {
    import (
        "fmt"
    )
    fmt.Println("x")
}
// 编译报错：import statement outside top-level block

// 正确写法：import 放到文件顶层；未使用的包用空白导入或变量引用"消费"掉
package main

import (
    _ "fmt" // 空白导入：只为触发包的 init，不实际使用其导出名
    "log"
    "time"
)

var _ = log.Println // 用变量引用"消费"导入，避免 "imported and not used"

func main() {
    _ = time.Now // 同理
}

func main() {
    var one int         // 声明了却没使用 → 编译错误：one declared but not used
    two := 2
    var three int
    three = 3
}

// 修复：显式"消费"掉，或用 _ 丢弃
func main() {
    var one int
    _ = one           // 用空白标识符丢弃，编译通过
    two := 2
    fmt.Println(two)
    var three int
    three = 3
    one = three       // 真正使用
}

func main() {
    one := 0
    // one := 1      // 错误：no new variables on left side of :=
    one, two := 1, 2 // OK：two 是新变量，one 被"半重声明"（重新赋值）
    one, two = two, one // OK：纯赋值，左右都已存在
    fmt.Println(one, two)
}

func main() {
    x := 1
    fmt.Println(x)    // 1
    i, x := 2, 2      // i 是新的，x 在同一作用域被重新赋值
    fmt.Println(i, x) // 2 2
    fmt.Println(x)    // 2（x 已被 := 重新绑定）
}

func main() {
    const x = 123  // 无类型整型常量
    const y = 1.23 // 无类型浮点常量
    fmt.Println(x) // 123
}

const (
    x uint16 = 120
    y               // 继承 x 的类型 uint16 与值 120
    s = "abc"
    z               // 继承 s 的类型 string 与值 "abc"
)

func main() {
    fmt.Printf("%T %v\n", y, y) // uint16 120
    fmt.Printf("%T %v\n", z, z) // string abc
}

func test(x byte) {
    fmt.Println(x)
}

func main() {
    var a byte = 0x11
    var b uint8 = a     // 直接赋值，无需转换（byte 即 uint8）
    var c uint8 = a + b // 直接运算
    test(c)             // c 是 uint8，传给 byte 参数也合法
}

func main() {
    // 步骤1：slice 字面量，尾逗号始终合法
    a := []int{1, 2, 3,}
    fmt.Println(a) // [1 2 3]

    // 步骤2：元素换行写时，行尾必须有逗号（gofmt 会自动补）
    b := []int{
        1,
        2,
        3, // 这个尾逗号是合法的，gofmt 下也推荐使用
    }
    fmt.Println(b)

    // 步骤3：map 字面量同理
    m := map[string]int{
        "a": 1,
        "b": 2, // 尾逗号合法
    }
    fmt.Println(m)
}

func main() {
    data := []int{1, 2, 3}
    i := 0
    // fmt.Println(data[i++]) // 编译错误：i++ 不是表达式，不能当索引

    // 正确：先自增，再使用
    i++
    fmt.Println(data[i]) // 2
}

// fmt.Println(~2) // 编译错误：invalid character U+007E '~'，Go 没有 ~ 取反符

func main() {
    // 步骤1：一元 ^ = 按位取反（补码下 ^a = -(a+1)）
    var a int8 = 3
    var b uint8 = 3
    var c int8 = -3
    fmt.Printf("^%b=%b %d\n", a, ^a, ^a) // ^11=-100 -4
    fmt.Printf("^%b=%b %d\n", b, ^b, ^b) // ^11=11111100 252
    fmt.Printf("^%b=%b %d\n", c, ^c, ^c) // ^-11=10 2

    // 步骤2：二元 ^ = 异或
    var x int8 = 3
    var y int8 = 5
    fmt.Printf("a^c: %08b\n", x^y) // 00000110 = 6

    // 步骤3：&^ = AND NOT（y 的位为 1 则结果位清 0）
    var m uint8 = 214 // 11010110
    var n uint8 = 92  // 01011100
    fmt.Printf("m&^n: %08b\n", m&^n) // 10000010
}

func main() {
    isMatch := func(i int) bool {
        switch i {
        case 1:
            // 空体：命中后直接结束 switch（不穿透）
        case 2:
            return true
        }
        return false
    }
    fmt.Println(isMatch(1)) // false（case 1 空，未穿透到 case 2）
    fmt.Println(isMatch(2)) // true

    // 用 fallthrough 显式穿透
    isMatch2 := func(i int) bool {
        switch i {
        case 1:
            fallthrough
        case 2:
            return true
        }
        return false
    }
    fmt.Println(isMatch2(1)) // true（穿透到 case 2）

    // 多个值合并到一个分支
    match := func(i int) bool {
        switch i {
        case 1, 2:
            return true
        }
        return false
    }
    fmt.Println(match(1)) // true
    fmt.Println(match(2)) // true
}