Gibt es eine Art wait bzw. sleep Methode auch außerhalb der Verwendung von Threads

[chocox]

Hallo zusammen,

ich möchte eine Webanwendung mit Hilfe von JSP und Servlets schreiben, bei der folgende Abhandlung gegeben ist:
In einem Startbildschirm wird vom Benutzer eine bestimmte Nummer eingegeben. Diese wird in eine XML-Datei geschrieben und in einem Dokumentverarbeitungsprogramm wird ermittelt, wie viele Druckaufträge zu dieser Nummer eingegangen sind. Dies ist aber nicht das Problem. Dieses Dokumentverarbeutungsprogramm liefert dann wiederum eine Datei mit der Anzahl der Aufträge. Während dieser Zeitspanne soll die Webanwendung schlafen und erst wenn die Datei ins Dateisystem geschrieben ist, dieses Ergebnis in einer weiteren Anweisung auf einer nächste Seite anzeigen. Gibt es eine Art sleep - Funktion, welche dafür verwendet werden kann? Also nochmal zur Zusammenfassung:
Eingabe einer Nummer - warten...warten - Auslesen der vom DMS zurückgelieferten Datei mit der Anzahl der Aufträge zu der Nummer und Ausgabe.

In einer while-Schleife in der immer wieder die Existenz der Datei abgefragt wird funktioniert es, ist aber unelegant wie ich finde.

Vielen Dank für eure Ideen.

 

[Technoblade]

Als Bibliotheksklasse nicht. Aber ich habe vor kurzem etwas ähnliches gemacht:

package network;

import java.util.ArrayList;
import java.util.Iterator;

public abstract class CmdListener
{
    private int phase;
    private ArrayList<WaitCard> waitingList;
    
    protected CmdListener()
    {
        waitingList = new ArrayList<WaitCard>();
    }

    public abstract void handleCmdEvent(CmdEvent e);
    
    protected void setPhase(int phase)
    {
        this.phase = phase;
        checkWaitingForPhases();
    }
    
    protected int getPhase()
    {
        return phase;
    }
    
    public void waitForPhase(int phase)
    {
        Thread t = Thread.currentThread();
        synchronized(this) {
            if(this.phase == phase) {
                return;                
            }
            
            new WaitCard(t, phase);
        }
        
        synchronized(t) {
            try {
                t.wait();
            }
            catch(InterruptedException iex) {
                System.out.println(iex);
            }
        }
            
    }
    
    private void checkWaitingForPhases()
    {
        synchronized(waitingList) {
            Iterator<WaitCard> it = waitingList.iterator();
            while(it.hasNext()) {
                WaitCard wc = it.next();
                if(!wc.waitLonger()) {
                    synchronized(wc.getWaitingThread()) {
                        wc.getWaitingThread().notify();
                        it.remove();
                    }
                }
            }
        }
    }
    
    private class WaitCard
    {
        private Thread waitingThread;
        private int phaseWaitedFor;
        
        public WaitCard(Thread t, int phase)
        {
            waitingThread = t;
            phaseWaitedFor = phase;
            synchronized(waitingList) {
                waitingList.add(this);
            }
        }
        
        public boolean waitLonger()
        {
            return phase != phaseWaitedFor;
        }
        
        public Thread getWaitingThread()
        {
            return waitingThread;
        }
    }
}

Das ganze ist bei mir jetzt leider noch unkommentiert. Bei mir war das ganze für eine Netzwerkimplementierung. Das System funktioniert recht simpel:
Aus einem belibiegen Kontext her raus wird die Methode waitForPhase(int phase)
aufgerufen. Über den an sich recht simplen weiteren Kontext in dem Verlauf wird der entsprechende Thread zum warten gezwungen. Jedes mal wenn sich jetzt die Phase des CmdListeners ändert wird überprüft welche Threads gegebenenfalls fortgesetzt werden.

Für das was du genannt hast wäre das mit den verschiedenen Phasen überflüssig, da du ja nur 2 Phasen hast. Von daher ließe sich das System noch vereinfachen.

Wenn du willst darfst du den Quelltext von mir übernehmen.

Edit: Du hattest bei dir erwähnt, das du keine Threads verwenden willst. Bei mir kommen zwar Threads vor, allerdings nur als Eckpunkt für das warten.

 

[Vereth]

Warum nutzt ihr nicht einfach die waitFor()-Methode der Process-Klasse in java.lang ? Oder startet ihr eure Programme irgendwie anders?