local mutex in SimpleQuery in socket.go

I tried to read code of mgo, and the function SimpleQuery in socket.go confused me. In this function, there are two local mutex:
https://github.com/go-mgo/mgo/blob/v2-unstable/socket.go

func (socket *mongoSocket) SimpleQuery(op *queryOp) (data []byte, err error) {
    var wait, change sync.Mutex
    var replyDone bool
    var replyData []byte
    var replyErr error
    wait.Lock()
    op.replyFunc = func(err error, reply *replyOp, docNum int, docData []byte) {
	    change.Lock()
	    if !replyDone {
		    replyDone = true
		    replyErr = err
		    if err == nil {
			    replyData = docData
		    }
	    }
	    change.Unlock()
	    wait.Unlock()
    }
    err = socket.Query(op)
    if err != nil {
	    return nil, err
    }
    wait.Lock()
    change.Lock()
    data = replyData
    err = replyErr
    change.Unlock()
    return data, err
}

As my understanding, for each call, there will be a new local mutex, so, it's actually protecting anything, why they put the mutex here?

They are synching the SimpleQuery with the replyFunc.

• wait is used to wait until replyFunc is really done.
• change is used to lock access to replyData and replyErr.

The mutexes are protecting data structures, they are both captured in the closure given to the replyFunc callback.

The wait mutex blocks until the callback returns, and the change mutex protects the replyData and replyErr values.

The commit that added those only says:

> Make SimpleQuery race safe, irrespective of what the server does.

So this may be extra protection against some unintended or legacy behavior, which is why it's using multiple mutexes rather than a single primitive to synchronize the operation.