为何要将displayState()方法声明为synchronized？

Great question—this is a common point of confusion when learning about thread safety in Java, so let's unpack it clearly using the SynchronizedBuffer context you provided:

• Guarantee Visibility of Shared Data
  Even though displayState() only reads shared mutable data from SynchronizedBuffer, synchronization isn't just for writes. Java's memory model lets threads cache local copies of shared variables. Without synchronization, a reading thread might pull a stale, outdated value from its cache instead of the most recent one written by another thread. Marking displayState() as synchronized forces the thread to read directly from main memory, ensuring it always sees the latest state.

• Avoid Inconsistent Partial Reads
  Imagine another thread is mid-way through modifying the shared data in a synchronized write method. If displayState() wasn't synchronized, it could read that data while it's in a half-updated, inconsistent state. Synchronization acts as a gate: either the entire write operation finishes before the read starts, or the read completes before any write begins. No messy in-between states allowed.

• Leverage Reentrant Locks for Safe Method Chaining
  Since other methods in SynchronizedBuffer are already synchronized (like the ones that modify the buffer), making displayState() synchronized plays nicely with Java's reentrant lock mechanism. If a thread already holds the object's lock (say, it's inside a synchronized write method and calls displayState()), it can re-acquire that same lock without deadlocking. This is critical for safe internal method calls—you don't want a thread to get stuck waiting for a lock it already owns.

Quick recap: Every Java object has an intrinsic monitor lock. Entering a synchronized method acquires this lock; exiting releases it. Reentrant locks mean a single thread can hold the same lock multiple times, which is essential for cases where synchronized methods call each other.

At the end of the day, marking displayState() as synchronized ensures the class maintains consistent, thread-safe behavior across all operations—even the ones that only read data. It's a key part of keeping the SynchronizedBuffer's shared state reliable when multiple threads are interacting with it.

内容的提问来源于stack exchange，提问作者user9398992