noname

package main

import (
    "fmt"
    "time"
)

func main() {
    // 定时器1
    timer1 := time.NewTimer(2 * time.Second)

    <-timer1.C
    fmt.Println("Timer 1 fired")

    // 定时器2
    timer2 := time.NewTimer(time.Second)
    go func() {
        <-timer2.C
        fmt.Println("Timer 2 fired")
    }()
    stop2 := timer2.Stop()
    if stop2 {
        fmt.Println("Timer 2 stopped")
    }

    // 定时器3
    time.Sleep(2 * time.Second)
}

package main

import (
    "fmt"
    "time"
)

func main() {
    // 每500ms执行一次
    ticker := time.NewTicker(500 * time.Millisecond)
    done := make(chan bool)

    go func() {
        for {
            select {
            case <-done:
                return
            case t := <-ticker.C:
                fmt.Println("Tick at", t)
            }
        }
    }()

    // 挂起休眠1600ms
    time.Sleep(1600 * time.Millisecond)
    // 停止定时器
    ticker.Stop()
    done <- true
    fmt.Println("Ticker stopped")
}

type pollDesc struct {
    _          sys.NotInHeap    // 放置转换成interface{}时申请heap内存
    link       *pollDesc        // next指针，用于pollcache链表
    fd         uintptr          // 文件描述符
    fdseq      atomic.Uintptr   // 计数器，类似时间戳，确保过期的消息不会被处理，只在获取/放回cache时改变
    atomicInfo atomic.Uint32    // 5个状态位+fdseq（这两个数据有位交叉冲突，没搞懂）
    rg         atomic.Uintptr   // 读状态，读G的地址也作为一种状态
    wg         atomic.Uintptr   // 写状态，写G的地址也作为一种状态
    lock       mutex            // 锁，保护下列字段
    closing    bool             // 是否被移除出netpoll
    rrun       bool             // rt-读定时器是否在运行
    wrun       bool             // wt-写定时器是否在运行
    user       uint32           // cookie，linux/bsd应该没用到
    rseq       uintptr          // 读计数器，类似fdseq，只有获取/放回cache以及设置deadline时改变
    rt         timer            // 读定时器
    rd         int64            // 读过期时刻，-1为已过期
    wseq       uintptr          // 写计数器，类似fdseq，只有获取/放回cache以及设置deadline时改变
    wt         timer            // 写定时器
    wd         int64            // 写过期时刻，-1为已过期
    self       *pollDesc        // 当前实例指针
}

// pollDesc缓存，重复使用，避免反复申请内存
type pollCache struct {
    lock  mutex                 // 锁
    first *pollDesc             // 链表头部指针，pollDesc指针都从头部写入 new -> old -> ...
}

package main

import (
    "fmt"
    "time"
)

func main() {
    p := fmt.Println

    // 当前时刻
    now := time.Now()
    p(now)

    // 指定时刻
    then := time.Date(
        2009, 11, 17, 20, 34, 58, 651387237, time.UTC)
    p(then)

    p(then.Year())          // 年
    p(then.Month())         // 月
    p(then.Day())           // 日
    p(then.Hour())          // 时
    p(then.Minute())        // 分
    p(then.Second())        // 秒
    p(then.Nanosecond())    // 纳秒
    p(then.Location())      // 时区

    p(then.Weekday())       // 星期

    // 判断两个时刻先后顺序
    p(then.Before(now))
    p(then.After(now))
    p(then.Equal(now))

    // 时长/时刻差值
    diff := now.Sub(then)
    p(diff)

    p(diff.Hours())         // 转换成总小时数
    p(diff.Minutes())       // 转换成总分钟数
    p(diff.Seconds())       // 转换成总秒数
    p(diff.Nanoseconds())   // 转换成总纳秒数

    p(then.Add(diff))
    p(then.Add(-diff))
}

message := make(chan string)

// 新goroutine
go func() {
    time.Sleep(time.Second * 2)
    message <- "Hello from goroutine!"
}()

// 当前goroutine
msg := <-message
fmt.Println(msg)

ch1 := make(chan int)
ch2 := make(chan int)

go func() {
    time.Sleep(time.Second * 1)
    ch1 <- 1
}()

go func() {
    time.Sleep(time.Second * 2)
    ch2 <- 2
}()

for i := 0; i < 2; i++ {
    select {
    case msg1 := <-ch1:
        fmt.Println("Received from ch1:", msg1)
    case msg2 := <-ch2:
        fmt.Println("Received from ch2:", msg2)
    }
}

//  root -> | idx0    | idx1       | ... | idx15 |
//          | &entry0 | &indirect0 | ... | nil   |
//                          |
//                       children
//                          v
//                    | idx0 | idx1    | ... | idx15 |
//                    | nil  | &entry1 | ... | nil   |

type HashTrieMap[K comparable, V any] struct {
    inited   atomic.Uint32                          // 是否已初始化
    initMu   Mutex                                  // 锁，用于初始化
    root     atomic.Pointer[indirect[K, V]]         // 根节点
    keyHash  hashFunc                               // 哈希函数，用于key
    valEqual equalFunc                              // cmp函数，用于value
    seed     uintptr                                // 哈希种子
}

// 内部节点
type indirect[K comparable, V any] struct {
    node[K, V]                                      // isEntry=false
    dead     atomic.Bool                            // 是否被删除
    mu       Mutex                                  // 锁，用于children
    parent   *indirect[K, V]                        // 父节点指针
    children [nChildren]atomic.Pointer[node[K, V]]  // 16个子节点，指向indirect或entry
}

// 叶子节点
type entry[K comparable, V any] struct {
    node[K, V]                                      // isEntry=true
    overflow atomic.Pointer[entry[K, V]]            // 指针，当两个entry哈希值相同时以链表方式存储
    key      K                                      // 键
    value    V                                      // 值
}

// entry和indirect的共有属性
type node[K comparable, V any] struct {
    isEntry bool                                    // 判断是叶子节点还是内部节点
}

type entry struct {
    p any
}

var m map[string]*entry

type entry struct {
    p *any
}
// read  -> key0|*entry0         entry0.p -> &value
//       -> key1|*entry1
//
// dirty -> key0|*entry0
//       -> key1|*entry1
//       -> key2|*entry2

package main

import (
    "fmt"
    "sync"
)

func main() {
    var syncMap sync.Map

    // 写
    syncMap.Store("blog", "VictoriaMetrics")

    // 读
    value, ok := syncMap.Load("blog")
    fmt.Println(value, ok)

    // 删除
    syncMap.Delete("blog")
    value, ok = syncMap.Load("blog")
    fmt.Println(value, ok)
}

package main

import (
    "fmt"
    "math/rand"
    "sync"
    "sync/atomic"
    "time"

    "golang.org/x/sync/singleflight"
)

var callCount atomic.Int32
var wg sync.WaitGroup

// 模拟db请求
func fetchData() (interface{}, error) {
    callCount.Add(1)
    time.Sleep(100 * time.Millisecond)
    // 返回的数据是随机的
    return rand.Intn(100), nil
}

// 包装fetchData和singleflight
func fetchDataWrapper(g *singleflight.Group, id int) error {
    defer wg.Done()

    time.Sleep(time.Duration(id) * 40 * time.Millisecond)
    v, err, shared := g.Do("key-fetch-data", fetchData)
    if err != nil {
        return err
    }

    fmt.Printf("Goroutine %d: result: %v, shared: %v\n", id, v, shared)
    return nil
}

func main() {
    var g singleflight.Group

    const numGoroutines = 5
    wg.Add(numGoroutines)

    // 模拟：发起5个请求访问db
    for i := 0; i < numGoroutines; i++ {
        go fetchDataWrapper(&g, i)
    }

    wg.Wait()
    fmt.Printf("Function was called %d times\n", callCount.Load())
}

package main

import (
    "fmt"
    "sync"
)

func main() {
    var size = 100
    var count int
    var wg sync.WaitGroup
    var rwm sync.RWMutex

    queue := make([]int, size)

    for i := 0; i < size; i++ {
        go func() {
            wg.Add(1)
            defer wg.Done()

            rwm.Lock()          // 写锁
            count++             // 更新资源
            rwm.Unlock()
        }()
    }

    for i := 0; i < size; i++ {
        indx := i
        go func() {
            wg.Add(1)
            defer wg.Done()

            rwm.RLock()         // 读锁
            queue[indx] = count // 只读
            rwm.RUnlock()
        }()
    }

    wg.Wait()

    fmt.Println(count)
    fmt.Println(queue)
}

package main

import (
    "fmt"
    "sync"
)

type Container struct {
    mu       sync.Mutex
    counters map[string]int
}

func (c *Container) inc(name string) {
    c.mu.Lock()         // 互斥锁，获取失败等待挂起
    defer c.mu.Unlock() // 解锁
    c.counters[name]++  // 共享资源
}

func main() {
    c := Container{
        counters: map[string]int{"a": 0, "b": 0},
    }

    var wg sync.WaitGroup

    doIncrement := func(name string, n int) {
        for i := 0; i < n; i++ {
            c.inc(name)
        }
        wg.Done()
    }

    wg.Add(3)
    go doIncrement("a", 10000)
    go doIncrement("a", 10000)
    go doIncrement("b", 10000)

    wg.Wait()
    fmt.Println(c.counters)
}