Simple Guide to Managing Shared Resources with Go Mutex

Has anyone used Go Mutex in their project?

When we should use Mutex?

How do you use Mutex properly and safely?

Mutex stands for 'mutual exclusion'. It ensures that only one goroutine can access a shared resource at any given time, preventing race conditions in concurrent programs.

To use mutex, you're just simply call Lock() or Unlock()

var mutex sync.Mutex

mutex.Lock() // Lock shared resouce
defer mutex.Unlock() // Unlock after you're done

// Do something with the resource

For a simple example, we can use a mutex when we write to a file.

package main

import (
    "fmt"
    "os"
    "sync"
    "time"
)

// We'll use a struct to encapsulate our data and mutex
type NumberWriter struct {
    count int
    mu    sync.Mutex
}

// Write the current count to the file
func (nw *NumberWriter) writeToFile(fileName string) {
    nw.mu.Lock()
    defer nw.mu.Unlock()

    err := os.WriteFile(fileName, []byte(fmt.Sprintf("%d\n", nw.count)), 0644)
    if err != nil {
        fmt.Println("Error writing to file:", err)
        return
    }
    nw.count++
}

func main() {
    nw := &NumberWriter{count: 0}

    fileName := "numbers.txt"
    numGoroutines := 5
    // WaitGroup to wait for all goroutines to finish
    var wg sync.WaitGroup

    for i := 0; i < numGoroutines; i++ {
        wg.Add(1)
        go func() {
            defer wg.Done()
            for j := 0; j < 10; j++ { // Each goroutine writes 10 numbers
                nw.writeToFile(fileName)
            }
        }()
    }

    wg.Wait()
    fmt.Println("Finished writing numbers to file.")
}

But sometimes, we don't have to use a mutex when using shared resources. First, in read-only scenarios or when the resource is already immutable.

Remember, always pair Lock() with Unlock() to avoid deadlocks. Using defer with Unlock() is a good practice to ensure the mutex is released correctly.