How to apply separate Mutex on multiple variables in Golang?

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

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<br>
How do i make all of them mutually exclusive without repeating this code?<br>
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.