Sync.Mutex در GO: یک مطالعه

package main

import (
    "fmt"
    "math/rand"
    "os"
    "strconv"
    "sync"
    "time"
)

func main() {
    // set concurrency count
    if len(os.Args) < 3 {
        fmt.Println("Usage: go run main.go [number] [useMutex]")
        return
    }
    maxLoopCount, err := strconv.Atoi(os.Args[1])
    if err != nil || maxLoopCount <= 0 {
        fmt.Println("Invalid number. Please provide a positive integer.")
        return
    }

    useMutex, err := strconv.ParseBool(os.Args[2])
    if err != nil {
        fmt.Println("Invalid string. Please provide a true or false.")
        return
    }

    // A mutex to prevent conflicts during progress updates.
    var mu sync.Mutex

    // WaitGroup for waiting until each goroutine has completed
    var wg sync.WaitGroup

    loopCount := 0
    for i := 0; i < maxLoopCount; i++ {
        wg.Add(1)
        go func() {
            defer wg.Done()
            time.Sleep(time.Duration(rand.Intn(400)+100) * time.Millisecond)
            if useMutex {
                mu.Lock()
                loopCount++
                mu.Unlock()
            } else {
                loopCount++
            }
        }()
    }

    // A channel to signal that all goroutines have finished
    done := make(chan struct{})
    go func() {
        wg.Wait()
        done <- struct{}{}
    }()

    // Periodically draw the progress status on the screen
    ticker := time.NewTicker(10 * time.Millisecond)
    defer ticker.Stop()

    for {
        select {
        case <-ticker.C:
            // Clear the screen and redraw
            printProgress(maxLoopCount, loopCount, &mu)
        case <-done:
            // Display the final state and exit
            printProgress(maxLoopCount, loopCount, &mu)
            return
        }
    }
}

// printProgress is a function that displays the progress of each indicator
// Prevent concurrent access to progress data using a mutex
func printProgress(maxLoopCount int, loopCount int, mu *sync.Mutex) {
    mu.Lock()
    defer mu.Unlock()

    // Clear the screen using ANSI escape sequences
    // \033[H : Move the cursor to the home position
    // \033[2J : Clear the screen
    fmt.Print("\033[H\033[2J")
    fmt.Printf("max loop count: %d\n", maxLoopCount)
    fmt.Printf("current loop count: %d\n", loopCount)

    // Set the total width of the progress bar to 50 characters
    width := 50
    progress := int((float64(loopCount) / float64(maxLoopCount)) * 100)

    // Number of "*" characters based on progress percentage
    stars := progress * width / 100
    spaces := width - stars
    fmt.Printf("%d.[%s%s] %d%%\n", 1, repeat("*", stars), repeat(" ", spaces), progress)
}

// repeat: Returns concatenated string by repeating string "s" "count" times
func repeat(s string, count int) string {
    result := ""
    for i := 0; i < count; i++ {
        result += s
    }
    return result
}

==================
WARNING: DATA RACE
Read at 0x00c000126048 by goroutine 417:
  main.main.func1()
      /path/to/main.go:47 +0xe8

Previous write at 0x00c000126048 by goroutine 23:
  main.main.func1()
      /path/to/main.go:47 +0xf8

Goroutine 417 (running) created at:
  main.main()
      /path/to/main.go:39 +0x440

Goroutine 23 (finished) created at:
  main.main()
      /path/to/main.go:39 +0x440
==================

package main

import (
    "fmt"
    "sync"
)

func main() {
    var mu sync.Mutex

    fmt.Println("Start: Lock - Unlock")
    mu.Lock()
    mu.Unlock()
    fmt.Println("End: Lock - Unlock")
    fmt.Println("---")

    fmt.Println("Start: TryLock - Unlock")
    b := mu.TryLock()
    fmt.Printf("TryLock() result is %v\n", b)
    mu.Unlock()
    fmt.Println("End: TryLock - Unlock")
    fmt.Println("---")

    fmt.Println("Start: Lock - TryLock - Unlock")
    mu.Lock()
    b = mu.TryLock()
    fmt.Printf("TryLock() result is %v\n", b)
    mu.Unlock()
    fmt.Println("End: Lock - TryLock - Unlock")
    fmt.Println("---")

    fmt.Println("Start: TryLock - TryLock - Unlock")
    b = mu.TryLock()
    fmt.Printf("TryLock()1 result is %v\n", b)
    b = mu.TryLock()
    fmt.Printf("TryLock()2 result is %v\n", b)
    mu.Unlock()
    fmt.Println("End: TryLock - TryLock - Unlock")
    fmt.Println("---")

    fmt.Println("Start: Lock - Lock - Unlock")
    mu.Lock()
    mu.Lock() // This causes a deadlock
    mu.Unlock()
    fmt.Println("End: Lock - Lock - Unlock")

    fmt.Println("Done.")
}

$ go run trylock.go
Start: Lock - Unlock
End: Lock - Unlock
---
Start: TryLock - Unlock
TryLock() result is true
End: TryLock - Unlock
---
Start: Lock - TryLock - Unlock
TryLock() result is false
End: Lock - TryLock - Unlock
---
Start: TryLock - TryLock - Unlock
TryLock()1 result is true
TryLock()2 result is false
End: TryLock - TryLock - Unlock
---
Start: Lock - Lock - Unlock
fatal error: all goroutines are asleep - deadlock!