抽象类中的同步

Question

I am working on Java Event Manager, and I want to add new future to it. It is custom class selection, or custom matching class system.

EventManager eventManager = new EventManager();

Ways how to set new class selector to event manager:

eventManager.setClassSelector(Class<? extends ClassSelector> classSelector);
eventManager.setClassSelector(ClassSelector classSelector);

This method using class selector:

eventManager.callEvent(event);

There is structure of ClassSelector

public abstract class ClassSelector{
    public List<Class<?>> classSelection(Class<?> clazz);
}

Method classSelection in ClassSelector must be synchronized, because callEvent is using ThreadPool with multiple Threads and only one instance of ClassSelector.

But synchronize key word is not inherited from super class. I need advice, how to solve this problem, by changing code or by changing logic.

Answer 1

It is pretty simple: when your abstract base class needs to "restrict" a method in a certain way (like: you want to enforce the method is synchronized ) - then that method should not be abstract.

Instead implement that method and make it final :

public abstract class ClassSelector{
   public final synchronized List<Class<?>> getClassSelection(Class<?> clazz) {
     return getSpecificClasses(clazz);
   }

   protected abstract List<Class<?>> getSpecificClasses(Class<?> clazz);

Now it is clear that a user of your class should call that public method - and that each subclass can only implement something that is guaranteed to be called in a synchronized manner.

(method naming isn't really great - just meant as example)

Answer 2

You could make classSelection a real method, that calls an abstract method. Each subclass would then only supply an implementation of the abstract method. This could look something like this.

public abstract class ClassSelector{
    public synchronized final List<Class<?>> classSelection(Class<?> clazz) {
        return doClassSelection(clazz);
    }
    protected List<Class<?>> doClassSelection(Class<?> clazz);
}

The final prevents someone from overriding your restriction, and implementing their own non-synchronized version of classSelection .