如何在Golang中的多个变量上应用单独的Mutex？

I have multiple variables which I want to make mutually exclusive using this method

type var1WithMutex struct {
    mu       sync.Mutex
    var1     int
}
func (v *var1) Set(value int) {
    v.mu.Lock()
    v.var1 = value
    v.mu.Unlock()
}
func (v *var1) Get() (value int) {
    v.mu.Lock()
    value = v.var1
    v.mu.Unlock()
    return
}

Similarly there are hundreds of variable, like var1, var2, var3.... var100
How do i make all of them mutually exclusive without repeating this code?
Note that var1, var2, var3 etc are not part of an array and no way related to each other. var2 may be a int and var3 may be User{}

You could make different Mutex object for each type instead. Playground

type MutexInt struct {
    sync.Mutex
    v int
}

func (i *MutexInt) Get() int {
    return i.v
}

func (i *MutexInt) Set(v int) {
    i.v = v
}

and use it like this

func main() {
    i := MutexInt{v: 0}
    i.Lock()
    i.Set(2)
    fmt.Println(i.Get())
    i.Unlock()
}

You can wrap your variables and use a shared mutex, if they all have the same interface (http://play.golang.org/p/xri2M-rtEY):

type Var interface {
    Get() int
    Set(n int)
}

func Sync(v Var, m *sync.RWMutex) Var {
    return &syncedVar{
        v: v,
        m: m,
    }
}

type syncedVar struct {
    m *sync.RWMutex
    v Var
}

func (v syncedVar) Get() int {
    v.m.RLock()
    defer v.m.RUnlock()
    return v.v.Get()
}

func (v *syncedVar) Set(n int) {
    v.m.Lock()
    defer v.m.Unlock()
    v.v.Set(n)
}

If your variables are primitive data types (int, float,..), use the sync.atomic package. Atomic operations do not need mutex.