Why does the condition contained in the mutex part not deadlock in this golang example?

In this golang example, the reason why deadlock will not occur with the conditions contained in the mutex part is because the mutex is passed through `Lock()` and `Unlock() ` method to achieve mutually exclusive access to shared resources. When a goroutine calls the `Lock()` method, if the mutex is already locked by another goroutine, the goroutine will be blocked until the mutex is released. This blocking mechanism ensures that when the mutex is locked, multiple goroutines will not access shared resources at the same time, thereby avoiding the occurrence of deadlock. So in this example, due to the correct usage of mutex, the condition will not be deadlocked.

Question content

I saw this example during a training at O'Reilly. There is a condition that should prevent widgetInventory from becoming negative. The example works, but I don't understand why the program doesn't deadlock when makeSales gets the mutex and widgetInventory is 0.

var (
    wg sync.WaitGroup
    mutex = sync.Mutex{}
    widgetInventory int32= 1000
    newPurchase = sync.NewCond(&mutex)
)

func main() {
    fmt.Println("Starting inventory count = ", widgetInventory)
    wg.Add(2)
    go makeSales()
    go newPurchases()
    wg.Wait()
    fmt.Println("Ending inventory count = ", widgetInventory)
}

func makeSales() {
    for i := 0; i < 3000; i++ {
        mutex.Lock()
        if widgetInventory-100 < 0{
            newPurchase.Wait()
        }
        widgetInventory -= 100
        fmt.Println(widgetInventory)
        mutex.Unlock()
    }
    wg.Done()
}

func newPurchases() {
    for i := 0; i < 3000; i++ {
        mutex.Lock()
        widgetInventory+= 100
        fmt.Println(widgetInventory)
        newPurchase.Signal()
        mutex.Unlock()
    }
    wg.Done()
}

I expect the code to deadlock when makeSales gets the mutex and widgetInventory is 0.

Solution

I didn't notice that the condition was associated with the mutex: newPurchase =sync.NewCond(&mutex) Entering .Wait() unlocks the mutex and attempts to reacquire it when the condition signal is received.

condition.Wait() can only be used when acquiring a mutex, so it works at the cost of less readable code :-)

The above is the detailed content of Why does the condition contained in the mutex part not deadlock in this golang example?. For more information, please follow other related articles on the PHP Chinese website!