How does a mutex.Lock() know which variables to lock?

问题

I'm a go-newbie, so please be gentle.

So I've been using mutexes in some of my code for a couple weeks now. I understand the concept behind it: lock access to a certain resource, interact with it (read or write), and then unlock it for others again.

The mutex code I use is mostly copy-paste-adjust. The code runs, but I'm still trying to wrap my head around it's internal working. Until now I've always used a mutex within a struct to lock the struct. Today I found this example though, which made it completely unclear for me what the mutex actually locks. Below is a piece of the example code:

var state = make(map[int]int)

var mutex = &sync.Mutex{}

var readOps uint64
var writeOps uint64

// Here we start 100 goroutines to execute repeated reads against the state, once per millisecond in each goroutine.
for r := 0; r < 100; r++ {
    go func() {
        total := 0
        for {
            key := rand.Intn(5)
            mutex.Lock()
            total += state[key]
            mutex.Unlock()
            atomic.AddUint64(&readOps, 1)

            time.Sleep(time.Millisecond)
        }
    }()
}

What puzzles me here is that there doesn't seem to be any connection between the mutex and the value it is supposed to lock. Until today I thought that the mutex can lock a specific variable, but looking at this code it seems to somehow lock the whole program into doing only the lines below the lock, until the unlock is ran again. I suppose that means that all the other goroutines are paused for a moment until the unlock is ran again. Since the code is compiled I suppose it can know what variables are accessed between the lock() and the unlock(), but I'm not sure if that is the case.

If all other programs pause for a moment, it doesn't sound like real multi-processing, so I'm guessing I don't have a good understanding of what's going on.

Could anybody help me out in understanding how the computer knows which variables it should lock?

回答1:

lock access to a certain resource, interact with it (read or write), and then unlock it for others again.

Basically yes.

What puzzles me here is that there doesn't seem to be any connection between the mutex and the value it is supposed to lock.

Mutex is just a mutual exclusion object that synchronizes access to a resource. That means, if two different goroutines want to lock the mutex, only the first can access it. The second goroutines now waits indefinitely until it can itself lock the mutex. There is no connection to variables whatsoever, you can use mutex however you want. For example only one http request, only one database read/write operation or only one variable assignment. While i don't advice the usage of mutex for those examples, the general idea should become clear.

but looking at this code it seems to somehow lock the whole program into doing only the lines below the lock, until the unlock is ran again.

Not the whole program, only every goroutine who wants to access the same mutex waits until it can.

I suppose that means that all the other goroutines are paused for a moment until the unlock is ran again.

No, they don't pause. They execute until they want to access the same mutex.

If you want to group your mutex specifically with a variable, why not create a struct?

来源：https://stackoverflow.com/questions/56719359/how-does-a-mutex-lock-know-which-variables-to-lock