Synchronisation in abstrakte Klasse

Question

Ich arbeite an Java Event Manager, und ich möchte neue Zukunft hinzufügen. Es ist benutzerdefinierte Klassenauswahl oder benutzerdefinierte übereinstimmende Klassensystem.

EventManager eventManager = new EventManager(); 

Möglichkeiten, wie neue Klasse Wähler auf Event-Manager zu setzen:

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

Diese Methode unter Verwendung von Klassenauswahl:

eventManager.callEvent(event); 

Es ist Struktur ClassSelector

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

Methode classSelection in ClassSelector muss synchronisiert werden, da callEvent ThreadPool mit mehreren Threads und nur einer Instanz von ClassSelector verwendet.

Aber synchronisieren Schlüsselwort ist nicht von der Superklasse geerbt. Ich brauche Ratschläge, wie ich dieses Problem lösen kann, indem ich den Code ändere oder die Logik ändere.

Answer 1

Es ist ziemlich einfach: Wenn Ihre abstrakte Basisklasse muss „beschränken“ eine Methode in einer bestimmten Art und Weise (wie: Sie ist die Methode synchronized erzwingen möchten) - dann diese Methode nicht abstrakt sein sollte.

Statt diese Methode implementieren und machen es final:

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

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

Nun ist es klar, dass ein Benutzer Ihrer Klasse, die öffentliche Methode nennen sollte - und dass jede Unterklasse kann nur etwas implementieren, ist garantiert synchronisiert aufgerufen werden.

(Methode Namensgebung ist nicht wirklich groß - genauso wie Beispiel gemeint)

Answer 2

Sie classSelection eine echte Methode machen könnte, die eine abstrakte Methode aufruft. Jede Unterklasse würde dann nur eine Implementierung der abstrakten Methode liefern. Das könnte in etwa so aussehen.

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

Die final verhindert jemand aus Ihrer Einschränkung überschreibt, und ihre eigene nicht-synchronisierte Version von classSelection implementieren.