Does Go support volatile / non-volatile variables?

I'm new to the language so bear with me.

I am curious how GO handles data storage available to threads, in the sense that non-local variables can also be non-volatile, like in Java for instance.

GO has the concept of channel, which, by it's nature -- inter thread communication, means it bypasses processor cache, and reads/writes to heap directly.

Also, have not found any reference to volatile in the go lang documentation.

TL;DR: Go does not have a keyword to make a variable safe for multiple goroutines to write/read it. Use the sync/atomic package for that. Or better yet Do not communicate by sharing memory; instead, share memory by communicating.

Two answers for the two meanings of volatile

.NET/Java concurrency

Some excerpts from the Go Memory Model.

> If the effects of a goroutine must be observed by another goroutine,
> use a synchronization mechanism such as a lock or channel
> communication to establish a relative ordering.

One of the examples from the Incorrect Synchronization section is an example of busy waiting on value.

> Worse, there is no guarantee that the write to done will ever be
> observed by main, since there are no synchronization events between
> the two threads. The loop in main is not guaranteed to finish.

Indeed, this code(play.golang.org/p/K8ndH7DUzq) never exits.

C/C++ non-standard memory

Go's memory model does not provide a way to address non-standard memory. If you have raw access to a device's I/O bus you'll need to use assembly or C to safely write values to the memory locations. I have only ever needed to do this in a device driver which generally precludes use of Go.

The simple answer is that volatile is not supported by the current Go specification, period.

If you do have one of the use cases where volatile is necessary, such as low-level atomic memory access that is unsupported by existing packages in the standard library, or unbuffered access to hardware mapped memory, you'll need to link in a C or assembly file.

Note that if you do use C or assembly as understood by the GC compiler suite, you don't even need cgo for that, since the [568]c C/asm compilers are also able to handle it.

You can find examples of that in Go's source code. For example:

• http://golang.org/src/pkg/runtime/sema.goc
• http://golang.org/src/pkg/runtime/atomic_arm.c

Grep for many other instances.

For how memory access in Go does work, check out The Go Memory Model.

No, go does not support the volatile or register statement.

See this post for more information.
This is also noted in the Go for C++ Programmers guide.

The Go Memory Model documentation explains why the concept of 'volatile' has no application in Go.

Loosely: Among other things, goroutines are free to keep goroutine-local changes cached in registers so those changes are not observable by other goroutines. To "flush" those changes to memory, a synchronization must be performed. Either by using locks or by communicating (channel send or receive).