|
| 1 | +// Copyright 2013 The Go Authors. All rights reserved. |
| 2 | +// Use of this source code is governed by a BSD-style |
| 3 | +// license that can be found in the LICENSE file. |
| 4 | + |
| 5 | +// Package singleflight provides a duplicate function call suppression |
| 6 | +// mechanism. |
| 7 | +package singleflight // import "github.com/catatsuy/sync/singleflight" |
| 8 | + |
| 9 | +import ( |
| 10 | + "bytes" |
| 11 | + "errors" |
| 12 | + "fmt" |
| 13 | + "runtime" |
| 14 | + "runtime/debug" |
| 15 | + "sync" |
| 16 | +) |
| 17 | + |
| 18 | +// errGoexit indicates the runtime.Goexit was called in |
| 19 | +// the user given function. |
| 20 | +var errGoexit = errors.New("runtime.Goexit was called") |
| 21 | + |
| 22 | +// A panicError is an arbitrary value recovered from a panic |
| 23 | +// with the stack trace during the execution of given function. |
| 24 | +type panicError struct { |
| 25 | + value any |
| 26 | + stack []byte |
| 27 | +} |
| 28 | + |
| 29 | +// Error implements error interface. |
| 30 | +func (p *panicError) Error() string { |
| 31 | + return fmt.Sprintf("%v\n\n%s", p.value, p.stack) |
| 32 | +} |
| 33 | + |
| 34 | +func (p *panicError) Unwrap() error { |
| 35 | + err, ok := p.value.(error) |
| 36 | + if !ok { |
| 37 | + return nil |
| 38 | + } |
| 39 | + |
| 40 | + return err |
| 41 | +} |
| 42 | + |
| 43 | +func newPanicError(v any) error { |
| 44 | + stack := debug.Stack() |
| 45 | + |
| 46 | + // The first line of the stack trace is of the form "goroutine N [status]:" |
| 47 | + // but by the time the panic reaches Do the goroutine may no longer exist |
| 48 | + // and its status will have changed. Trim out the misleading line. |
| 49 | + if line := bytes.IndexByte(stack[:], '\n'); line >= 0 { |
| 50 | + stack = stack[line+1:] |
| 51 | + } |
| 52 | + return &panicError{value: v, stack: stack} |
| 53 | +} |
| 54 | + |
| 55 | +// call is an in-flight or completed singleflight.Do call |
| 56 | +type call[V any] struct { |
| 57 | + wg sync.WaitGroup |
| 58 | + |
| 59 | + // These fields are written once before the WaitGroup is done |
| 60 | + // and are only read after the WaitGroup is done. |
| 61 | + val V |
| 62 | + err error |
| 63 | + |
| 64 | + // These fields are read and written with the singleflight |
| 65 | + // mutex held before the WaitGroup is done, and are read but |
| 66 | + // not written after the WaitGroup is done. |
| 67 | + dups int |
| 68 | + chans []chan<- Result[V] |
| 69 | +} |
| 70 | + |
| 71 | +type Group[K comparable] struct { |
| 72 | + g Group2[K, struct{}] |
| 73 | +} |
| 74 | + |
| 75 | +func (g *Group[K]) Do(key K, fn func() error) (error, bool) { |
| 76 | + _, err, shared := g.g.Do(key, func() (struct{}, error) { |
| 77 | + return struct{}{}, fn() |
| 78 | + }) |
| 79 | + return err, shared |
| 80 | +} |
| 81 | + |
| 82 | +func (g *Group[K]) Forget(key K) { |
| 83 | + g.g.Forget(key) |
| 84 | +} |
| 85 | + |
| 86 | +// Group2 represents a class of work and forms a namespace in |
| 87 | +// which units of work can be executed with duplicate suppression. |
| 88 | +type Group2[K comparable, V any] struct { |
| 89 | + mu sync.Mutex // protects m |
| 90 | + m map[K]*call[V] // lazily initialized |
| 91 | +} |
| 92 | + |
| 93 | +// Result holds the results of Do, so they can be passed |
| 94 | +// on a channel. |
| 95 | +type Result[V any] struct { |
| 96 | + Val V |
| 97 | + Err error |
| 98 | + Shared bool |
| 99 | +} |
| 100 | + |
| 101 | +// Do executes and returns the results of the given function, making |
| 102 | +// sure that only one execution is in-flight for a given key at a |
| 103 | +// time. If a duplicate comes in, the duplicate caller waits for the |
| 104 | +// original to complete and receives the same results. |
| 105 | +// The return value shared indicates whether v was given to multiple callers. |
| 106 | +func (g *Group2[K, V]) Do(key K, fn func() (V, error)) (v V, err error, shared bool) { |
| 107 | + g.mu.Lock() |
| 108 | + if g.m == nil { |
| 109 | + g.m = make(map[K]*call[V]) |
| 110 | + } |
| 111 | + if c, ok := g.m[key]; ok { |
| 112 | + c.dups++ |
| 113 | + g.mu.Unlock() |
| 114 | + c.wg.Wait() |
| 115 | + |
| 116 | + if e, ok := c.err.(*panicError); ok { |
| 117 | + panic(e) |
| 118 | + } else if c.err == errGoexit { |
| 119 | + runtime.Goexit() |
| 120 | + } |
| 121 | + return c.val, c.err, true |
| 122 | + } |
| 123 | + c := new(call[V]) |
| 124 | + c.wg.Add(1) |
| 125 | + g.m[key] = c |
| 126 | + g.mu.Unlock() |
| 127 | + |
| 128 | + g.doCall(c, key, fn) |
| 129 | + return c.val, c.err, c.dups > 0 |
| 130 | +} |
| 131 | + |
| 132 | +// DoChan is like Do but returns a channel that will receive the |
| 133 | +// results when they are ready. |
| 134 | +// |
| 135 | +// The returned channel will not be closed. |
| 136 | +func (g *Group2[K, V]) DoChan(key K, fn func() (V, error)) <-chan Result[V] { |
| 137 | + ch := make(chan Result[V], 1) |
| 138 | + g.mu.Lock() |
| 139 | + if g.m == nil { |
| 140 | + g.m = make(map[K]*call[V]) |
| 141 | + } |
| 142 | + if c, ok := g.m[key]; ok { |
| 143 | + c.dups++ |
| 144 | + c.chans = append(c.chans, ch) |
| 145 | + g.mu.Unlock() |
| 146 | + return ch |
| 147 | + } |
| 148 | + c := &call[V]{chans: []chan<- Result[V]{ch}} |
| 149 | + c.wg.Add(1) |
| 150 | + g.m[key] = c |
| 151 | + g.mu.Unlock() |
| 152 | + |
| 153 | + go g.doCall(c, key, fn) |
| 154 | + |
| 155 | + return ch |
| 156 | +} |
| 157 | + |
| 158 | +// doCall handles the single call for a key. |
| 159 | +func (g *Group2[K, V]) doCall(c *call[V], key K, fn func() (V, error)) { |
| 160 | + normalReturn := false |
| 161 | + recovered := false |
| 162 | + |
| 163 | + // use double-defer to distinguish panic from runtime.Goexit, |
| 164 | + // more details see https://golang.org/cl/134395 |
| 165 | + defer func() { |
| 166 | + // the given function invoked runtime.Goexit |
| 167 | + if !normalReturn && !recovered { |
| 168 | + c.err = errGoexit |
| 169 | + } |
| 170 | + |
| 171 | + g.mu.Lock() |
| 172 | + defer g.mu.Unlock() |
| 173 | + c.wg.Done() |
| 174 | + if g.m[key] == c { |
| 175 | + delete(g.m, key) |
| 176 | + } |
| 177 | + |
| 178 | + if e, ok := c.err.(*panicError); ok { |
| 179 | + // In order to prevent the waiting channels from being blocked forever, |
| 180 | + // needs to ensure that this panic cannot be recovered. |
| 181 | + if len(c.chans) > 0 { |
| 182 | + go panic(e) |
| 183 | + select {} // Keep this goroutine around so that it will appear in the crash dump. |
| 184 | + } else { |
| 185 | + panic(e) |
| 186 | + } |
| 187 | + } else if c.err == errGoexit { |
| 188 | + // Already in the process of goexit, no need to call again |
| 189 | + } else { |
| 190 | + // Normal return |
| 191 | + for _, ch := range c.chans { |
| 192 | + ch <- Result[V]{c.val, c.err, c.dups > 0} |
| 193 | + } |
| 194 | + } |
| 195 | + }() |
| 196 | + |
| 197 | + func() { |
| 198 | + defer func() { |
| 199 | + if !normalReturn { |
| 200 | + // Ideally, we would wait to take a stack trace until we've determined |
| 201 | + // whether this is a panic or a runtime.Goexit. |
| 202 | + // |
| 203 | + // Unfortunately, the only way we can distinguish the two is to see |
| 204 | + // whether the recover stopped the goroutine from terminating, and by |
| 205 | + // the time we know that, the part of the stack trace relevant to the |
| 206 | + // panic has been discarded. |
| 207 | + if r := recover(); r != nil { |
| 208 | + c.err = newPanicError(r) |
| 209 | + } |
| 210 | + } |
| 211 | + }() |
| 212 | + |
| 213 | + c.val, c.err = fn() |
| 214 | + normalReturn = true |
| 215 | + }() |
| 216 | + |
| 217 | + if !normalReturn { |
| 218 | + recovered = true |
| 219 | + } |
| 220 | +} |
| 221 | + |
| 222 | +// Forget tells the singleflight to forget about a key. Future calls |
| 223 | +// to Do for this key will call the function rather than waiting for |
| 224 | +// an earlier call to complete. |
| 225 | +func (g *Group2[K, V]) Forget(key K) { |
| 226 | + g.mu.Lock() |
| 227 | + delete(g.m, key) |
| 228 | + g.mu.Unlock() |
| 229 | +} |
0 commit comments