func Get() int64 {
 var buf [64]byte
 runtime.Stack(buf[:], false)

 s := buf[len("goroutine "):]
 s = s[:bytes.IndexByte(s, ' ')]

 gid, _ := strconv.ParseInt(string(s), 10, 64)

 return gid
}

// func getg() *g
TEXT ·getg(SB),NOSPLIT,$0-8
#ifdef GOARCH_386
 MOVL (TLS), AX
 MOVL AX, ret+0(FP)
#endif
#ifdef GOARCH_amd64
 MOVQ (TLS), AX
 MOVQ AX, ret+0(FP)
#endif
#ifdef GOARCH_arm
 MOVW g, ret+0(FP)
#endif
#ifdef GOARCH_arm64
 MOVD g, ret+0(FP)
#endif
#ifdef GOARCH_s390x
 MOVD g, ret+0(FP)
#endif
 RET

func Get() int64 {
 return getg().goid
}

func (o *Once) Do(f func())

if o.done.CompareAndSwap(0, 1) {
 f()
}

// Note: Here is an incorrect implementation of Do:
//
// if o.done.CompareAndSwap(0, 1) {
//  f()
// }

In the terminology of the "Go memory model", the return from f "synchronizes before" the return from any call of once.Do(f).

...
if !o.done.Load() {
    o.doSlow(f)
}
...

func (o *Once) doSlow(f func()) {
    o.m.Lock()
    defer o.m.Unlock()
    if !o.done.Load() {
        defer o.done.Store(true)
        f()
    }
}

Состояние во время исполнения, когда две операции над переменной происходят из разных горутин без синхронизации, при этом хотя бы одна из них является записью.

Состояние во время исполнения, когда две конфликтующие операции над переменной происходят из разных горутин без синхронизации.

Состояние во время исполнения, когда две конфликтующие операции над переменной нельзя разделить отношением happens before

type Cron interface {
 Run(ctx context.Context, action func(), next func() time.Duration)
}

func (c *cronImpl) Run(ctx context.Context, action func(), next func() time.Duration) {
 var t *time.Timer

 t = time.AfterFunc(next(), func() {
  select {
  case <-ctx.Done():
   return
  default:
   action()
   t.Reset(next())
  }
 })

 <-ctx.Done()
}

func TestCron(t *testing.T) {
 synctest.Test(t, func(t *testing.T) {
  c := New()

  var n atomic.Int64
  next := func() time.Duration {
   if n.Add(1) <= 5 {
    return 0
   }

   return 1 * time.Second
  }

  var calls atomic.Int64
  ctx, cancel := context.WithCancel(t.Context())

  t.Cleanup(func() {
   cancel()
  })

  done := make(chan struct{})
  go func() {
   defer close(done)

   c.Run(ctx, func() {
    calls.Add(1)
   }, next)
  }()

  synctest.Wait()

  require.Greater(t, calls.Load(), int64(0))

  cancel()
  synctest.Wait()

  select {
  case <-done:
  default:
   t.Fatalf("Run did not exit after cancel")
  }
 })
}

func (c *cronImpl) Run(ctx context.Context, action func(), next func() time.Duration) {
 var t *time.Timer

 t = time.AfterFunc(next(), func() {
  select {
  case <-ctx.Done():
   return
  default:
   action()
   t.Reset(next())
  }
 })

 <-ctx.Done()
}

func main() {
 ctx, cancel := context.WithTimeout(context.Background(), time.Second*10)
 defer cancel()

 c := cronImpl{}
 c.Run(ctx,
  func() {
   fmt.Println("Hello, @igoroutine")
  },
  func() time.Duration {
   return time.Second
  },
 )
}

Hello, @igoroutine
Hello, @igoroutine
Hello, @igoroutine
Hello, @igoroutine
Hello, @igoroutine
Hello, @igoroutine
Hello, @igoroutine
Hello, @igoroutine
Hello, @igoroutine
Hello, @igoroutine

Program exited 0.

go test -v -race ./...

func TestCron(t *testing.T) {
 synctest.Test(t, func(t *testing.T) {
  c := New()

  var n atomic.Int64
  next := func() time.Duration {
   if n.Add(1) <= 5 {
    return 0
   }

   return 1 * time.Second
  }
  
  var calls atomic.Int64
  ctx, cancel := context.WithCancel(t.Context())

  done := make(chan struct{})
  go func() {
   defer close(done)

   c.Run(ctx, func() {
    calls.Add(1)
   }, next)
  }()

  synctest.Wait()

  require.Greater(t, calls.Load(), int64(0))

  cancel()
  synctest.Wait()

  select {
  case <-done:
  default:
   t.Fatalf("Run did not exit after cancel")
  }
 })
}

=== RUN TestCron
--- PASS: TestCron (0.00s)
PASS

panic: runtime error: invalid memory address or nil pointer dereference
[signal SIGSEGV: segmentation violation code=0x2 addr=0x0 pc=0x1009927fc]

go test -v -count=10000 ./...
PASS
ok 0.787s

go test -v -race -count=100 ./...
PASS
ok 4.079s

WARNING: DATA RACE
Read at 0x00c0000024a0 by goroutine 3543:
cron.go:30 +0x90 // t.Reset(next())

Previous write at 0x00c0000024a0 by goroutine 3541:
cron.go:24 +0x194 // t = time.AfterFunc(next() ...

panic: runtime error: invalid memory address or nil pointer dereference
[signal SIGSEGV: segmentation violation code=0x2 addr=0x0 pc=0x1050ae7fc]

func AfterFunc(d Duration, f func()) *Timer {
 return newTimer(when(d), 0, goFunc, f, nil)
}

func goFunc(arg any, seq uintptr, delta int64) {
 go arg.(func())()
}

t = time.AfterFunc(next(), func() {
        ...
 t.Reset(next())
})

type set[K comparable] struct {
  data map[K]struct{}
}

A struct or array type has size zero if it contains no fields (or elements, respectively) that have a size greater than zero.

type bmap struct {
  tophash [8]uint8
  keys [8]K
  values [8]V
  overflow *bmap
}

type group struct {
  ctrl uint64
  slots [abi.SwissMapGroupSlots]struct {
    key  keyType
    elem elemType
  }
}

type group struct {
  ctrl uint64
  slots [abi.SwissMapGroupSlots]struct {
    key  keyType
    elem elemType
  }
}

map[addrDetail]struct {}: key=24 elem=0 slot=32
map[any]struct {}: key=16 elem=0 slot=24
map[canceler]struct {}: key=16 elem=0 slot=24
map[*conn]struct {}: key=8 elem=0 slot=16
map[GoID]struct {}: key=8 elem=0 slot=16
map[*http2serverConn]struct {}: key=8 elem=0 slot=16
map[*net.Listener]struct {}: key=8 elem=0 slot=16
map[ProcID]struct {}: key=8 elem=0 slot=16
map[string]struct {}: key=16 elem=0 slot=24
map[_typePair]struct {}: key=16 elem=0 slot=24
map[uintptr]struct {}: key=8 elem=0 slot=16

map[addrDetail]struct {}: key=24 elem=0 slot=24
map[any]struct {}: key=16 elem=0 slot=16
map[canceler]struct {}: key=16 elem=0 slot=16
map[*conn]struct {}: key=8 elem=0 slot=8
map[GoID]struct {}: key=8 elem=0 slot=8
map[*http2serverConn]struct {}: key=8 elem=0 slot=8
map[*net.Listener]struct {}: key=8 elem=0 slot=8
map[ProcID]struct {}: key=8 elem=0 slot=8
map[string]struct {}: key=16 elem=0 slot=16
map[_typePair]struct {}: key=16 elem=0 slot=16
map[uintptr]struct {}: key=8 elem=0 slot=8

// key returns a pointer to the key at index i.
func (g *groupReference) key(typ *abi.MapType, i uintptr) unsafe.Pointer {
  offset := groupSlotsOffset + i*typ.SlotSize

  return unsafe.Pointer(uintptr(g.data) + offset)
}

// elem returns a pointer to the element at index i.
func (g *groupReference) elem(typ *abi.MapType, i uintptr) unsafe.Pointer {
  offset := groupSlotsOffset + i*typ.SlotSize + typ.ElemOff

  return unsafe.Pointer(uintptr(g.data) + offset)
}