Is synchronization required?

I defined a variable (r.something) inside an object

func (r *Runner) init() {
  r.something = make(map[string]int)
  r.something["a"]=1

  go r.goroutine()
}

while r.goroutine uses value stored in r.something with no synchronization.
Nobody else is going to read/write this value except r.goroutine()

Is it safe to do without synchronization?

In other words: I want to reuse some variable from a goroutine initialized somewhere else before goroutine start. Is that safe?

Additional question:
After r.goroutine() finishes I want to be able to use r.something from somewhere else(without read/write overlap with other goroutines). Is it safe too?

Of course this is safe, otherwise programming in Go might be a nightmare (or at least much less pleasant). The Go Memory Model is an interesting piece to read.

The routine creation is a synchronisation point. There is an example very similar to yours:

var a string

func f() {
	print(a)
}

func hello() {
	a = "hello, world"
	go f()
}

With the following comment:
> calling hello will print "hello, world" at some point in the future (perhaps after hello has returned).

This is because:

> The go statement that starts a new goroutine happens before the goroutine's execution begins.

The word before is crucial here as it implies routine creation (in one thread) must be synchronised with its start (possibly in other thread), so writes to a must be visible by the new routine.

If there is no situation where an overlap of read and write operations by different go-routines may occur on this variable, then you are right: there is no need for any synchonization.

As you have mentioned that the variable was initialized before your go-routine started, you are in fact safe.

Yes, it is safe. According to Go Memory Model:

• the go statement that starts a new goroutine happens before the goroutine's execution begins
• within a single goroutine, the happens-before order is the order expressed by the program

This means that all changes to variables that you made before starting a goroutine are visible inside this goroutine.

Answer to your additional question: it depends. Generally if r.goroutine() modified r.something and you want to read it from another goroutine you need to use synchronisation.