Hallo,
wir sind dabei einen Fifo Aspect Springseitig zu implementieren (MethodInvocation). Zu Testzwecken habe ich dies via Proxy nachgebildet. Um die Details geht es aber eigentlich garnicht, sondern eher um die richtige Verwendung des Lock Objekts mit den synchronized Blöcken.
Meine erste Lösung war folgende:
Allerdings ist laut Dozent die Anordnung der synchronized Blöcke falsch + die queue.add(...) Methode sollte innerhalb eines synchronen Blocks aufgerufen werden. Die "gesamte FIFO-Funktionalität sei so kaputtgemacht"
Jetzt hätte ich noch folgende Lösung:
Ich sehe aber nicht wirklich warum das besser sein sollte bzw. was der Unterschied ist...
Außer der Tatsache, dass die Threads schon während der MethodInvocation gequeued werden können....???
Warum sollte queue.add(...) in den synchronized Block?
Und Warum ist bei Variante 1 die Fifo-Funktionalität kaputtgemacht? Laut meinen Tests werden die Threads in richtiger Reihenfolge abgearbeitet... :???
P.S.: Ich weiß nicht, ob Variante 2 richtig ist, wenn Fehler auffallen bitte korrigieren
Vielen Dank schon mal für die Hilfe!!!
LG
Alex
wir sind dabei einen Fifo Aspect Springseitig zu implementieren (MethodInvocation). Zu Testzwecken habe ich dies via Proxy nachgebildet. Um die Details geht es aber eigentlich garnicht, sondern eher um die richtige Verwendung des Lock Objekts mit den synchronized Blöcken.
Meine erste Lösung war folgende:
Java:
public class FifoServiceInvocationHandler implements InvocationHandler {
private Object lock = new Object();
private Object service;
private Queue<Thread> queue = new LinkedList<Thread>();
public FifoServiceInvocationHandler() {
service = new MySimpleService();
}
@Override
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
System.out.println("Invoked by " + (String)args[0]);
queue.add(Thread.currentThread());
synchronized (lock) {
try {
while(queue.peek() != Thread.currentThread()) {
lock.wait();
}
return method.invoke(service, (String)args[0]);
} finally {
queue.remove();
lock.notifyAll();
}
}
}
}
Allerdings ist laut Dozent die Anordnung der synchronized Blöcke falsch + die queue.add(...) Methode sollte innerhalb eines synchronen Blocks aufgerufen werden. Die "gesamte FIFO-Funktionalität sei so kaputtgemacht"
Jetzt hätte ich noch folgende Lösung:
Java:
public class FifoServiceInvocationHandler implements InvocationHandler {
private Object lock = new Object();
private Object service;
private Queue<Thread> queue = new LinkedList<Thread>();
public FifoServiceInvocationHandler() {
service = new MySimpleService();
}
@Override
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
System.out.println("Invoked by " + Thread.currentThread().getId() + " command " + (String)args[0]);
try {
synchronized (lock) {
queue.add(Thread.currentThread());
while (queue.peek() != Thread.currentThread()) {
lock.wait();
}
}
return method.invoke(service, (String)args[0]);
} finally {
synchronized (lock) {
queue.remove();
lock.notifyAll();
}
}
}
}
Ich sehe aber nicht wirklich warum das besser sein sollte bzw. was der Unterschied ist...
Außer der Tatsache, dass die Threads schon während der MethodInvocation gequeued werden können....???
Warum sollte queue.add(...) in den synchronized Block?
Und Warum ist bei Variante 1 die Fifo-Funktionalität kaputtgemacht? Laut meinen Tests werden die Threads in richtiger Reihenfolge abgearbeitet... :???
P.S.: Ich weiß nicht, ob Variante 2 richtig ist, wenn Fehler auffallen bitte korrigieren
Vielen Dank schon mal für die Hilfe!!!
LG
Alex
Zuletzt bearbeitet: