Go Sync or Go Home: Advanced Concurrency Techniques for Better Go Programs

Go Sync or Go Home Advanced Concurrency Techniques for Better
Go Programs @yardenlaif

2 Who Am I? • Software Engineer at Rookout •
Go, Java, Ruby • C#, Python, JavaScript, C++ • Amateur sewist

3 Go + concurrency = 🩵

sync & x/sync • sync - standard library • x/sync
- go get golang.org/x/sync 4

Features • Mutex - Mutual exclusion lock • Once -
Run an action once only • Pool - Memory pool to save on allocations • RWMutex - Lock that allows several concurrent reads but only one write • WaitGroup - Wait for a group of goroutines to ﬁnish • Semaphore - Weighted lock • Map - Map implementation that is safe for concurrent use 5

File Transfer App 6 • Transfer each ﬁle to multiple
destinations • Given: type File struct { ... } type Conn interface { Send(context.Context, *File) error } • Implement: func TransferFile(ctx context.Context, conns []Conn, file *File)

File Transfer App - WaitGroup 7 func TransferFile(ctx context.Context, conns
[]Conn, file *File) { wg := sync.WaitGroup{} for _, conn := range conns { wg.Add(1) go func(c Conn) { defer wg.Done() c.Send(ctx, file) }(conn) } wg.Wait() }

[]Conn, file *File) { wg := sync.WaitGroup{} for _, conn := range conns { wg.Add(1) go func(c Conn) { defer wg.Done() c.Send(ctx, file) }(conn) } wg.Wait() } Send(context.Context, *File) error

15 WaitGroup ErrGroup Add(int) Done() Go(f func() error) Wait() Wait()
error

16 WaitGroup ErrGroup wg := sync.WaitGroup{} wg.Add(n) for i :=
0; i < n; i++ { go func() { defer wg.Done() task() }() } wg.Wait() eg := errgroup.Group{} for i := 0; i < n; i++ { eg.Go(task) } err := eg.Wait()

File Transfer App - ErrGroup 19 func TransferFile(ctx context.Context, conns
[]Conn, file *File) error { eg := errgroup.Group{} for _, conn := range conns { func(c Conn) { eg.Go(func() error { return c.Send(ctx, file) }) }(conn) } return eg.Wait() }

[]Conn, file *File) error { eg := errgroup.Group{} for _, conn := range conns { func(c Conn) { eg.Go(func() error { return c.Send(ctx, file) }) }(conn) } return eg.Wait() } Send(context.Context, *File) error

ErrGroup - WithContext func WithContext(ctx context.Context) (*Group, context.Context) 25

ErrGroup - WithContext func WithContext(ctx context.Context) (*Group, context.Context) eg :=
errgroup.Group{} eg, _ := errgroup.WithContext(...) 26

ErrGroup - WithContext func WithContext(ctx context.Context) (*Group, context.Context) 27

[]Conn, file *File) error { eg, egCtx := errgroup.WithContext(ctx) for _, conn := range conns { func(c Conn) { eg.Go(func() error { return c.Send(egCtx, file) }) }(conn) } return eg.Wait() }

ErrGroup - SetLimit • SetLimit(n int) Set maximum number of
goroutines running at once • TryGo(f func() error) bool Try to run task in new goroutine if limit hasn’t been reached • Go(f func() error) Block until able to run goroutine if limit has been reached 29

30 SingleFlight

SingleFlight • Imported by 1,215 projects • The golang repo
has its own internal copy of singleﬂight • Duplicate function call suppression mechanism 31

Token Authenticator 32 type Token interface { AuthenticateToken(ctx context.Context, token
string) (*Response, bool, error) } type Response struct { ... }

Token Authenticator Cache 33 type cacheRecord struct { resp *Response
ok bool err error } type cache interface { get(key string) (value *cacheRecord, exists bool) set(key string, value *cacheRecord, ttl time.Duration) remove(key string) }

Cached Token Authenticator 34 type cta struct { authenticator Token
cache cache } func (a *cta) AuthenticateToken(ctx context.Context, token string) (*Response, bool, error)

Cached Token Authenticator 35 func (a *cta) AuthenticateToken(ctx context.Context, token
string) (*Response, bool, error) { if record, exists := a.cache.get(token); exists { return record.resp, record.ok, record.err } resp, ok, err := a.authenticator.AuthenticateToken(ctx, token) record := &cacheRecord{resp, ok, err} a.cache.set(token, record, defaultTTL) return resp, ok, err }

Cached Token Authenticator 40 func authTwice(a *cta, token string) {
go a.AuthenticateToken(token) go a.AuthenticateToken(token) } • Check cache • Authenticate • Add to cache • Return response

go a.AuthenticateToken(token) go a.AuthenticateToken(token) } • Check cache • Authenticate • Add to cache • Return response 1 2

go a.AuthenticateToken(token) go a.AuthenticateToken(token) } • Check cache • Authenticate • Add to cache • Return response 1 2 1

go a.AuthenticateToken(token) go a.AuthenticateToken(token) } • Check cache • Authenticate • Add to cache • Return response 1 2 1 2

SingleFlight - `Do` Method func (g *Group) Do(key string, fn
func() (interface{}, error)) (v interface{}, err error, shared bool) 48

func() (interface{}, error)) (v interface{}, err error, shared bool) 49 g := singleflight.Group{} g.Do(...)

func() (interface{}, error)) (v interface{}, err error, shared bool) 50 g := singleflight.Group{} g.Do(key, func() (interface{}, error) { value, err := getValue(key) return value, err })

func() (interface{}, error)) (v interface{}, err error, shared bool) 51 g := singleflight.Group{} value, err, _ := g.Do(key, func() (interface{}, error) { value, err := getValue(key) return value, err })

Cached Token Authenticator 52 type cta struct { authenticator Token
group singleflight.Group cache cache }

string) (*Response, bool, error) { if record, exists := a.cache.get(token); exists { return record.resp, record.ok, record.err } record, _, _ := a.group.Do(token, func() (interface{}, error) { resp, ok, err := a.authenticator.AuthenticateToken(ctx, token) record := &cacheRecord{resp, ok, err} a.cache.set(token, record, defaultTTL) return record, nil }) realRecord := record.(*cacheRecord) return realRecord.resp, realRecord.ok, realRecord.err }

string) (*Response, bool, error) type Token interface { AuthenticateToken(ctx context.Context, token string) (*Response, bool, error) }

SingleFlight - `DoChan` Method func (g *Group) Do(key string, fn
func() (interface{}, error)) (v interface{}, err error, shared bool) func (g *Group) DoChan(key string, fn func() (interface{}, error)) <-chan Result type Result struct { Val interface{} Err error Shared bool } 61

string) (*Response, bool, error) { // Check cache c := a.group.DoChan(token, func() (interface{}, error) { // Authenticate and set cache }) select { case result := <-c: record := result.Val.(*cacheRecord) return record.resp, record.ok, record.err case <-ctx.Done(): return nil, false, ctx.Err() } }

SingleFlight Extras func (g *Group) Forget(key string) • https://pkg.go.dev/tailscale.com/uti l/singleflight
- Generics! 69

Cond • Broadcast • Signal • Wait 70

Cond • Broadcast • Signal • Wait • For many
simple use cases, users will be better off using channels than a Cond (Broadcast corresponds to closing a channel, and Signal corresponds to sending on a channel). • For more on replacements for sync.Cond, see Roberto Clapis's series on advanced concurrency patterns, as well as Bryan Mills's talk on concurrency patterns 71

Discovering Packages • pkg.go.dev • github.com • https://pkg.go.dev/std • https://pkg.go.dev/golang.org/x
72

Cached Token Authenticator? 74 • https://github.com/kubernetes/apiserver/blob/d8bdd263c241c be9f5c1357541f622f48457207e/pkg/authentication/token/cach e/cached_token_authenticator.go

Thank You! @yardenlaif 75

Go Sync or Go Home: Advanced Concurrency Techni...

Go Sync or Go Home: Advanced Concurrency Techniques for Better Go Programs

More Decks by Yarden Laifenfeld

Other Decks in Programming

Featured

Transcript