Should getters and setters be synchronized?

by

I think its best to cite Java Concurrency in Practice here:

It is a common mistake to assume that synchronization needs to be used only when writing to shared variables; this is simply not true.

For each mutable state variable that may be accessed by more than one
thread, all accesses to that variable must be performed with the same
lock held. In this case, we say that the variable is guarded by that
lock.

In the absence of synchronization, the compiler, processor, and runtime can do some downright weird things to the order in which operations appear to execute. Attempts to reason about the order in which memory actions “must” happen in insufflciently synchronized multithreaded programs will almost certainly be incorrect.

Normally, you don’t have to be so careful with primitives, so if this would be an int or a boolean it might be that:

When a thread reads a variable without synchronization, it may see a
stale value, but at least it sees a value that was actually placed
there by some thread rather than some random value.

This, however, is not true for 64-bit operations, for instance on long or double if they are not declared volatile:

The Java Memory Model requires fetch and
store operations to be atomic, but for nonvolatile long and double
variables, the JVM is permitted to treat a 64-bit read or write as two
separate 32-bit operations. If the reads and writes occur in different
threads, it is therefore possible to read a nonvolatile long and get
back the high 32 bits of one value and the low 32 bits of another.

Thus, even if you don’t care about stale values, it is not safe to use
shared mutable long and double variables in multithreaded programs
unless they are declared volatile or guarded by a lock.

More Related Contents:

  1. What does ‘synchronized’ mean?
  2. Avoid synchronized(this) in Java?
  3. Difference between volatile and synchronized in Java
  4. Is there an advantage to use a Synchronized Method instead of a Synchronized Block?
  5. Synchronizing on String objects in Java
  6. Java synchronized static methods: lock on object or class
  7. Java synchronized method lock on object, or method?
  8. Is HttpSession thread safe, are set/get Attribute thread safe operations?
  9. Java Synchronized Block for .class
  10. Synchronization of non-final field
  11. Happens-before relationships with volatile fields and synchronized blocks in Java – and their impact on non-volatile variables?
  12. Static versus non-static lock object in synchronized block
  13. If I synchronized two methods on the same class, can they run simultaneously?
  14. Is ConcurrentHashMap totally safe?
  15. In Java critical sections, what should I synchronize on?
  16. What is the difference between synchronized on lockObject and using this as the lock?
  17. What is the difference between a synchronized method and synchronized block in Java? [duplicate]
  18. do we need volatile when implementing singleton using double-check locking
  19. Why can’t Java constructors be synchronized?
  20. Should you synchronize the run method? Why or why not?
  21. Java volatile modifier and synchronized blocks
  22. Java Multithreading concept and join() method
  23. Why are synchronize expensive in Java?
  24. Difference between Synchronized block with wait/notify and without them?
  25. Do two synchronized methods execute simultaneously
  26. What is the reason why “synchronized” is not allowed in Java 8 interface methods?
  27. Is synchronized inherited in Java?
  28. Learning Java, use of synchronized keyword
  29. If a synchronized method calls another non-synchronized method, is there a lock on the non-synchronized method
  30. Side effects of throwing an exception inside a synchronized clause?

Leave a Comment