Actually Java guarantees atomic accesses for integer-sized fields and references at the language level. They aren't race-free, but they are atomic. And really, atomicity is the main property that the OP had in mind when posting. Since you mentioned C++, it also does guarantee certain-sized certain-alignment loads and stores are atomic.
In Java there is also the plethora of thread safe data structures available in java.util.concurrent. They are written by experts and are pretty darn fast (TM). It might have been reasonable to use one of these as the basis for Go map implementations, but the language designers chose to assume unsynchronized access to shared maps is a design bug in applications.
Re:Are Go maps sensitive to data races?
by jeremyjh on Monday December 07, 2015 @07:02AM
(#10688881)
Java chooses safety over performance. It is not free to check for concurrent access in a non-concurrent structure. In some languages, we let the programmer take on the choice of which costs to bear. There is not very much that I like about Go, but there is nothing wrong with having non-concurrent data structures that are documented as such and fail in non-defined ways when there is shared data access.
> Java chooses safety over performance.
Yet manages to be faster than golang.
Also, the two need not be mutually exclusive as you're implying.
Re:Are Go maps sensitive to data races?
by viraptor on Monday December 07, 2015 @06:59AM
(#10688870)
C got atomic values in C11: http://en.cppreference.com/w/c/language/atomic
Not that I disagree with your comment in general, but atomic values do exist in many languages.
Re:Are Go maps sensitive to data races?
by AYBABTME on Monday December 07, 2015 @07:05AM
(#10688888)
Also in Go https://golang.org/pkg/sync/atomic/
Thanks for the reference, I knew about C11 atomic types, and, I should have use a better phrasing. Note that C11 atomics are still not applicable to multi-word aggregate types, like structs. You'd use atomics in C11 (in the type system), for what you'd use sync/atomic (like other poster mentioned) in Go (outside the type system).
Re:Are Go maps sensitive to data races?
by seanmcdirmid on Monday December 07, 2015 @07:18AM
(#10688940)
32 bit data types are read and written atomically on the CLR. Pointers are read/written atomicly on most ANY platform, or you couldn't build any kind of higher level concurrency abstraction. If not, the language could never provide memory safety.
You need a way to do atomic reads and writes, but you don't need to have atomic types. In Go you just use sync/atomic which implements atomicity outside the type system.
When you use "regular" operations, you don't get atomicity, but what you get is well-defined, and explained here: https://golang.org/ref/mem.
Re:Are Go maps sensitive to data races?
by grabcocque on Monday December 07, 2015 @06:35AM
(#10688787)
I apologise for expecting better of language designers. After all, the solutions to these sorts of issues has only been around for a couple of decades. Far too soon.
Re:Are Go maps sensitive to data races?
by alkonaut on Monday December 07, 2015 @06:43AM
(#10688813)
This is a library thing, not a language thing. And it's a performance tradeoff: they could have shipped with a concurrent map only, that is 1/10 as fast as the current one, but never causes a data race. However everyone that isn't doing anything concurrently would be paying for it. Not very clever. I trust the class library designers thought this through. They reached the same conclusion as pretty much every other library designer in every other language. For the same reasons.
Data races are not the same thing as non-atomic accesses.
Re:Are Go maps sensitive to data races?
by alkonaut on Monday December 07, 2015 @07:01AM
(#10688877)
Sorry, I interpreted the statement as being about concurrency in maps, not about atomicity.
Re:Are Go maps sensitive to data races?
by netheril96 on Monday December 07, 2015 @06:50AM
(#10688835)
You are not expecting better. You are expecting worse. Plenty of use cases involve maps without concurrent modification, e.g., when used as a local variable. Your "better" version of maps will slow down all of them.
Re:Are Go maps sensitive to data races?
by jrockway on Monday December 07, 2015 @06:40AM
(#10688803)
All the language designer can do is throw in a lock that you may or may not need if you're already locking properly. ConcurrentModificationException is nice, but comes at a performance cost.
Re:Are Go maps sensitive to data races?
by lazyjones on Monday December 07, 2015 @07:17AM
(#10688936)
The explanation for this design decision is reasonable IMHO: https://golang.org/doc/faq#atomic_maps
Maps are not concurrency-safe, you know what else isn't? Integers, floats, pointers, structs. And not only in Go, but in pretty much almost all languages with mutable state, like C and C++.
The map implementation in Go is consistent with the rest of the language, plus it allows for great performance under some rather common scenarios.
But I guess it's fashionable to snark on message boards than rather understand all these facts.