Go Mutex and RWMutex: Difference between revisions

From NovaOrdis Knowledge Base
Jump to navigation Jump to search
Line 44: Line 44:
=Patterns=
=Patterns=
==<span id='Extending_a_struct_with_a_Mutex'></span>Guarding the Internal State of a <tt>struct</tt>==
==<span id='Extending_a_struct_with_a_Mutex'></span>Guarding the Internal State of a <tt>struct</tt>==
Guarding the internal state of a <code>struct</code> is is one of the not very numerous patterns where a <code>sync</code> primitive is [[Go_Concurrency#Programming_Models|actually recommended]].
Guarding the internal state of a <code>struct</code> is is one of the not very numerous patterns where a <code>sync</code> primitive is [[Go_Concurrency#Programming_Models|actually recommended]]. This pattern defines the [[Concurrent_(Parallel)_Programming#Atomicity|scope of atomicity]] for the <code>SomeType</code> type. Calls to <code>something()</code> can be considered atomic.
<syntaxhighlight lang='go'>
<syntaxhighlight lang='go'>
type SomethingWithALock struct {
type SomeType struct {
   name string
   name string
   ...
   ...
Line 52: Line 52:
}
}


func (s * SomethingWithALock) something() {
func (s * SomeType) something() {
   s.Lock()
   s.Lock()
   defer s.Unlock()
   defer s.Unlock()
}
}
</syntaxhighlight>
</syntaxhighlight>

Revision as of 23:55, 15 January 2024

External

Internal

Overview

Mutex

https://pkg.go.dev/sync#Mutex

A Mutex is a mutual exclusion lock, implemented as a binary semaphore. Only one goroutine can enter the critical section at a time. Not until the call to the Unlock() function issued can another goroutine enter the critical section.

The usage pattern follows, and the curly braces are not necessary, but can be used for clarity:

var mutex sync.Mutex

...

mutex.Lock() 

// do something in a mutual exclusion mode

mutex.Unlock()

Methods

Lock()

The goroutine should call Lock() before it is about to use the shared data. If nobody called Lock() before, the call will proceed and the calling goroutine will acquire the lock. If somebody else has the lock, the call will block. Multiple threads may potentially block on the same lock.

Lock() ensures that only one thread can be in the mutually exclusion region.

Unlock()

The goroutine that is done using the shared data should call Unlock(). If other threads are waiting on the lock, one of the threads will be unblocked and will be able to continue.

A mutex that was not locked raises a panic on an attempt to unlock:

fatal error: sync: unlock of unlocked mutex

RWMutex

https://pkg.go.dev/sync#RWMutex

A RWMutex is a mutual exclusion lock that allows differentiated access to readers and writers.

Patterns

Guarding the Internal State of a struct

Guarding the internal state of a struct is is one of the not very numerous patterns where a sync primitive is actually recommended. This pattern defines the scope of atomicity for the SomeType type. Calls to something() can be considered atomic.

type SomeType struct {
  name string
  ...
  sync.RWMutex
}

func (s * SomeType) something() {
  s.Lock()
  defer s.Unlock()
}