Are 64 bit assignments in Java atomic on a 32 bit machine?

by

Here is the short summary:

  • For references, reads/writes are ALWAYS atomic (even in 64 bit implementations!)
  • For int, char, byte, short, boolean, float, reads/writes are ALWAYS atomic
  • For double and long, if they’re volatile, reads/writes are ALWAYS atomic

Therefore there is only exception where reads/writes may not be atomic:

  • For double and long, if they’re NOT declared volatile, they’re NOT GUARANTEED to be atomic

So as far as atomicity of reading/writing shared data is concerned, you only need to make volatile any double or long. Everything else is already guaranteed to be atomic, regardless of how many bits are used in actual implementation.

On the specification

Here’s the relevant section reproduced here for quick reference:

JLS 17.7 Non-atomic Treatment of double and long

Some implementations may find it convenient to divide a single write action on a 64-bit long or double value into two write actions on adjacent 32 bit values. For efficiency’s sake, this behavior is implementation specific; Java virtual machines are free to perform writes to long and double values atomically or in two parts.

For the purposes of the Java programming language memory model, a single write to a non-volatile long or double value is treated as two separate writes: one to each 32-bit half. This can result in a situation where a thread sees the first 32 bits of a 64 bit value from one write, and the second 32 bits from another write. Writes and reads of volatile long and double values are always atomic. Writes to and reads of references are always atomic, regardless of whether they are implemented as 32 or 64 bit values.

VM implementors are encouraged to avoid splitting their 64-bit values where possible. Programmers are encouraged to declare shared 64-bit values as volatile or synchronize their programs correctly to avoid possible complications.

See also

Related questions

More Related Contents:

  1. How to wait for all threads to finish, using ExecutorService?
  2. Is there an advantage to use a Synchronized Method instead of a Synchronized Block?
  3. When and how should I use a ThreadLocal variable?
  4. What is the difference between Thread.start() and Thread.run()?
  5. Java Wait and Notify: IllegalMonitorStateException
  6. Are static variables shared between threads?
  7. How do synchronized static methods work in Java and can I use it for loading Hibernate entities?
  8. Is iterating ConcurrentHashMap values thread safe?
  9. Why use a ReentrantLock if one can use synchronized(this)?
  10. Java Executors: how can I set task priority?
  11. Is it safe to get values from a java.util.HashMap from multiple threads (no modification)?
  12. Volatile variable in Java
  13. What is the JVM thread scheduling algorithm?
  14. How do I implement task prioritization using an ExecutorService in Java 5?
  15. Why does Thread.isInterrupted () always return false?
  16. Constructor synchronization in Java
  17. More efficient way for pausing loop wanted
  18. How does `this` reference to an outer class escape through publishing inner class instance?
  19. Javafx: Difference between javafx.concurent and Platform.runLater?
  20. Are non-synchronised static methods thread safe if they don’t modify static class variables?
  21. Instruction reordering & happens-before relationship [duplicate]
  22. When should we use Java’s Thread over Executor?
  23. Which concurrent Queue implementation should I use in Java?
  24. Why should I use concurrent characteristic in parallel stream with collect?
  25. Jboss Java EE container and an ExecutorService
  26. Why doesn’t volatile in java 5+ ensure visibility from another thread?
  27. Concurrent JUnit testing
  28. How to pause/resume all threads in an ExecutorService in Java?
  29. Handling Exceptions for ThreadPoolExecutor
  30. Multithreading Socket communication Client/Server

Leave a Comment