There are several reasons a synchronized modifier on a method may be a bad idea:

1. As little work as possible should be performed under a lock. Therefore it is often better to use a synchronized block and keep there only the code that works with shared state.
2. Synchronization becomes a part of a method's interface. This makes a transition to a different locking mechanism difficult.
3. Keeping track of what is locking a particular object gets harder.
4. The DoS (denial-of-service) attack becomes feasible either on purpose or unknowingly when inheriting the method's class.

As an alternative, consider synchronizing on a private final lock object, access to which can be completely controlled.

A quick-fix is provided to wrap the method body with synchronized(this).

Example:

  class Main {
    public synchronized void fooBar() {
    }
  }

After the quick-fix is applied:

  class Main {
    public void fooBar() {
      synchronized (this) {
      }
    }
  }

You can configure the following options for this inspection:

1. Include native methods - include native methods into the inspection's scope.
2. Ignore methods overriding a synchronized method - do not report methods that override a synchronized method.