Klasse vor parallelem Zugriff absichern
Ich habe hier mal ne Klasse, zu der ich euren Rat brauche:
Code:
import java.io.Serializable;
import java.util.LinkedList;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.locks.ReentrantLock;
public final class MsM implements Serializable {
private static final long serialVersionUID = -7772563564882078067L;
private static final MsM manager = new MsM();
private final ReentrantLock messagesLock = new ReentrantLock();
private final ReentrantLock filtersLock = new ReentrantLock();
private LinkedBlockingQueue<Object> messages;
private LinkedList<FilterPlugin> filters;
private MsM() {
this.messages = new LinkedBlockingQueue<Object>();
this.filters = new LinkedList<FilterPlugin>();
}
public static MsM getInstance() {
return MsM.manager;
}
public void addFilter(FilterPlugin plugin) {
final ReentrantLock addLock = this.filtersLock;
addLock.lock();
try {
this.filters.add(plugin);
} finally {
addLock.unlock();
}
}
public void clearFilters() {
final ReentrantLock clearLock = this.filtersLock;
clearLock.lock();
try {
this.filters.clear();
} finally {
clearLock.unlock();
}
}
public void addMessage(Object message) throws MoeException {
final ReentrantLock putLock = this.messagesLock;
final ReentrantLock iterLock = this.filtersLock;
try {
putLock.lockInterruptibly();
iterLock.lockInterruptibly();
for (FilterPlugin plugin : this.filters) {
message = plugin.filter(message);
if (message == null)
break;
}
if (message != null)
this.messages.put(message);
} catch (InterruptedException e) {
throw new MoeException("Queue interrupted in put() method!");
} finally {
iterLock.unlock();
putLock.unlock();
}
}
public synchronized boolean hasMessages() {
return this.messages.size() > 0;
}
public Object getMessage() {
final ReentrantLock takeLock = this.messagesLock;
takeLock.lock();
Object o = null;
try {
o = this.messages.poll();
} finally {
takeLock.unlock();
}
return o;
}
}
Die Instanz dieser Klasse wird von mehreren Threads genutzt.
1. Thread fuegt dauernd neue Nachrichten hinzu
2. Dieser Thread holt die Nachrichten aus der Klasse wieder raus
und
3. Der Thread fuegt Filter hinzu, diese Filter werden beim Hinzufuegen der Nachrichten benutzt um bestimmte Daten zu filtern.
Nun habe ich die Klasse mit 2 ReentrantLock abgesichert.
Zugegeben, ich habe nicht wirklich viel Erfahrung mit mehr als einem Thread, aber koennte das so passen?
Hoffe jemand macht sich die Muehe darueber nachzudenken.
mfg
