Datenstruktur .. BlockingQueue (LIFO)

[diggaa1984]

hiho,

ich habe eine Anforderung die verlangt, dass ich je nach Strategie verschiedene Abarbeitungsreihenfolgen von Anfragen umsetzen muss:

FIFO = first in first out
LIFO = last in first out
HIFO = highest in first out (complexity - attribut in Klasse MyQuery)
LOFO = lowest in first out (ebenfalls über complexity realisiert)
RAFO = random first out

complexity wird in MyQuery in der compareTo-Methode genutzt, als "natürliche Ordnung".
Im Code nutze ich dann noch eine Sequenznummer um identisch komplexe Anfragen nach Eingang zu sortieren (nur der Info wegen).

das ganze sieht nun so aus, je nach Strategie nutz ich eine andere Datenstruktur.

public class SearchEngine implements Runnable {

	public enum Strategy {
		FIFO,
		HIFO,
		LIFO,
		LOFO,
		RAFO;
	}//Strategy
	
	private Strategy strategy;
	private BlockingQueue<MyQuery> queue;
	private double rate;
	private boolean keepRunning;
	
	
	public SearchEngine(Strategy strategy, double rate) {
		this.strategy = strategy;
		this.rate = rate;
		keepRunning = true;
		
		switch (strategy) {
			case FIFO:
				queue = new LinkedBlockingQueue<MyQuery>();
				break;
			case HIFO:
				queue = new PriorityBlockingQueue<MyQuery>(11, new Comparator<MyQuery>() {
					public int compare(MyQuery first, MyQuery second) {
						int result = first.compareTo(second) *(-1); 
						if (result == 0) {
							return (first.getSeqNum() < second.getSeqNum()? -1:1);
						} else {
							return result; 
						}//if
					}//compare
				});
				break;
			case LIFO:
				//FEHLERHAFT, kann net casten zur Laufzeit :) .. Versuch meinerseits
				queue = (BlockingQueue<MyQuery>) Collections.asLifoQueue(new LinkedBlockingDeque<MyQuery>());
				break;
			case LOFO:
				queue = new PriorityBlockingQueue<MyQuery>(11, new Comparator<MyQuery>() {
					public int compare(MyQuery first, MyQuery second) {
						int result = first.compareTo(second); 
						if (result == 0) {
							return (first.getSeqNum() < second.getSeqNum()? -1:1);
						} else {
							return result; 
						}//if
					}//compare
				});
				break;
			case RAFO:
				queue = new PriorityBlockingQueue<MyQuery>(11, new Comparator<MyQuery>() {
					Random rand = new Random();
					public int compare(MyQuery first, MyQuery second) {
						//random insertion into list
						return rand.nextInt(3)-1;
					}//compare
				});
				break;
		}//sitch
	}//constructor

bis auf LIFO funktionieren alle wie erwartet. Bei Lifo bekommt er zu Runtime ne ClassCastException, was ich fast angenommen hatte 🙁

Exception in thread "main" java.lang.ClassCastException: java.util.Collections$AsLIFOQueue cannot be cast to java.util.concurrent.BlockingQueue
at SearchEngine.<init>(SearchEngine.java:47)
at Main.setupEngines(Main.java:18)
at Main.main(Main.java:9)

Die Frage ist, wie bekomm ich am einfachsten ne LIFO die das BlockingQueue-Interface widerspiegelt, muss ich mir das selbst basteln?

Collections.asLifoQueue()

liefert mir ja

Queue<T>

zurück, das müsste nun eine BlockingQueue werden 😀

 

[diggaa1984]

niemand eine Idee, oder schlichtweg zu unverständlich formuliert? 🙂

 

[XHelp]

Du bekommst nicht zwingen eine BlockingQueue zurück, deswegen kannst du ja auch nicht zu BlockingQueue casten.
Kannst ja

queue

nur als

Queue

deklarieren.

 

[diggaa1984]

scheint als müsst ich mir selbst was bauen