1. Synchronized Methods

When a method is declared as synchronized, only one thread can execute that method on a particular object at a time. This is particularly useful when you have methods that access shared resources or modify shared variables. You can synchronize instance methods or static methods.

• Instance Method:

  java

  Copy

  public synchronized void methodName() {
// method logic
}


  For instance methods, the synchronization is applied on the instance of the object. Each object has its own lock, so if one thread is executing a synchronized method of an object, other threads can still execute synchronized methods on other objects.

• Static Method:

  java

  Copy

  public static synchronized void methodName() {
// method logic
}


  For static methods, the lock is applied on the class itself, meaning that no thread can execute any static synchronized method of the class at the same time.

2. Synchronized Blocks

Instead of synchronizing the entire method, you can synchronize only a specific block of code within a method. This allows for finer control over synchronization and can improve performance, as it reduces the amount of code that needs to be locked.

• Example of Synchronized Block:
  java

  Copy

  public void methodName() {
synchronized (this) {
// synchronized code block
}
}


  In this case, the code inside the synchronized block will be executed by only one thread at a time. The object in parentheses (e.g., this or a custom object) is the lock object. You can also synchronize on class-level objects for static methods.

Key Points to Understand:

1. Locks and Monitors: Every object in Java has an intrinsic lock (monitor). A synchronized block or method acquires the lock before proceeding. Only one thread can hold the lock at any given time for a particular object.
2. Deadlock: If two or more threads are waiting for each other to release a lock, a deadlock occurs. It’s crucial to design synchronization carefully to avoid deadlock situations.
3. Thread Safety: The synchronized keyword ensures that only one thread can access the critical section (shared resource), preventing data inconsistency or race conditions.
4. Performance Impact: Synchronization can affect performance because it adds overhead due to lock management. Fine-tuning the scope of synchronized blocks can mitigate this issue.

Common Interview Questions on synchronized:

1. What does the synchronized keyword do in Java, and how does it ensure thread safety?
2. What is the difference between synchronizing a method and synchronizing a block of code?
3. Can you synchronize a constructor in Java? If not, why?
4. What is the difference between synchronized methods and static synchronized methods?
5. What is a deadlock, and how can you prevent it when using synchronized?
6. How does the intrinsic lock (monitor) work in Java?
7. What are some alternatives to using synchronized in Java for managing concurrency?