Thread - Kontrolle

[filth]

Hallo,

ich habe eine Frage - evtl verzettele ich mich gerade an einem Punkt.
Eine meiner Klassen startet 3 Threads, die unterschiedliche Aufgaben abarbeiten. Nachdem alle Threads fertig sind, wird in der Klasse, die die Threads startet eine Variable gesetzt, die mir anzeigt, dass die Arbeit fertig ist.

Das ganze sieht so aus:

/**
	 * This will start the upload -> all steps are initiated from here
	 */
	public void startUpload()
	{
		// iterate over all selected events
		for (int i = 0; i < getEventList().size(); i++)
		{
			Event currentEvent = getEventList().get(i);
						
			// process only events with added pics
			if(currentEvent.getEventPics().size() > 0)
			{
				PackUploader myPackuploader = new PackUploader( this, currentEvent );
				myPackuploader.uploadPics();
				
				// now wait until uploader is done before starting with next event
				while(myPackuploader.isActive())
				{
				   // HIER SOLL GEWARTET WERDEN	
				}
			}									
		}
	}

Die Packuploader Klasse startet die Threads. In dem oberen Codeschnippsel soll gewartet werden, bis die Abarbeitung fertig ist und mit dem nächsten Event aus dem Vector fortgefahren werden.
Die Threads verändern einen Fortschrittsbalken in der GUI und machen einige Berechnungen.
Wie kann ich diese Warteprozedur umsetzen? Bzw ist evtl meine Architektur an dem Punkt ganz falsch?

Danke!

 

[Marco13]

Ob es einen Grund gibt, warum das in einem eigenen Thread gemacht werden soll, wenn an dieser Stelle ohnehin gewartet wird, weiß ich nicht (das bezieht sich darauf, das eine Methode, die sinngemäß so aussieht

void doSomething()
{
    waitUntilFinished(new Thread() { executeIt(); });
}

eventuell (!) auch

void doSomething()
{
    executeIt();
}

sein könnte.

Aber wenn das alles Sinn macht: Man könnte dieses Verhalten mit wait/notify steuern

class PackUploader
{
    void uploadPics()
    {
        ...
        synchronized (this) { notifyAll(); }
    }
}


void doit()
{
    PackUploader myPackuploader = new PackUploader( this, currentEvent );
    myPackuploader.uploadPics();
                
    synchronized (myPackuploader) {
        myPackuploader.wait(); // try/catch drum
    }
}

(EDIT: Das ist quasi "pseudocode" - an deinem Beispiel sieht man nicht genau, wo wann welcher Thread was macht!)

Etwas schöner/sauberer/moderner mit den Mitteln aus Java Platform SE 6, aber da brüuchte man ggf. mehr infos.

 

[SlaterB]

warten kannst du mit wait() am Thread-Objekt oder ganz einfach Thread.sleep(),
es gibt verkürzt eine Methode join(), die so ziemlich genau das macht, abgesehen davon dass sie bei Interrupt/notify aufwacht, Quellcode siehe unten

im Moment startest du einen Thread, wartest auf dessen Ende, startest den zweiten, wartest auf dessen Ende usw.,
nicht ganz sinnvoll, dann könnte all diese Arbeit auch der Aufrufer selber machen,
du möchtest vielleicht eher alle drei Threads starten und DANACH bei allen drei Join aufzurufen, um auf das Ende aller drei zu warten

warum wartest du aber überhaupt? die Methode scheint danach nichts mehr zu machen außer eben bisher doch alle Aktionen hintereinander auszuführen mit zweifelhaften Sinn für mehrere Threads,

wichtig auch noch: wenn startUpload() aus einem Listener der GUI aus aufgerufen wird, dann wäre diese bis zum Ende der Methode blockiert,
kein Fortschrittsbalken zu sehen,
es bringt nix die Arbeit in einen Thread zu verlegen wenn der GUI-Thread dieselbe Zeit dann wartet und auch blockiert ist,
das Warten muss, wenn überhaupt nötig, auch in einen Thread

    /**
     * Waits at most <code>millis</code> milliseconds for this thread to 
     * die. A timeout of <code>0</code> means to wait forever. 
     *
     * @param      millis   the time to wait in milliseconds.
     * @exception  InterruptedException if another thread has interrupted
     *             the current thread.  The <i>interrupted status</i> of the
     *             current thread is cleared when this exception is thrown.
     */
    public final synchronized void join(long millis) 
    throws InterruptedException {
	long base = System.currentTimeMillis();
	long now = 0;

	if (millis < 0) {
            throw new IllegalArgumentException("timeout value is negative");
	}

	if (millis == 0) {
	    while (isAlive()) {
		wait(0);
	    }
	} else {
	    while (isAlive()) {
		long delay = millis - now;
		if (delay <= 0) {
		    break;
		}
		wait(delay);
		now = System.currentTimeMillis() - base;
	    }
	}
    }

 

[filth]

Hi,

also startUpload() wird aus der GUI gestartet, aber der Fortschrittsbalken ist einwandfrei zu sehen. Deswegen doch die Threads - die blockieren die GUI nicht. Würde ich statt den 3 Threads, die eigentlich nur nacheinander abgearbeitet werden 3 statische Methoden aufrufen, dann wäre die GUI blockiert.

Oder sehe ich das falsch?

In der startUpload - Methode kann ich nicht mit sleep() warten, da diese Klasse kein Thread ist

 

[SlaterB]

> Oder sehe ich das falsch?

es steht doch alles schon da..., was nützen nebenläufige Threads wenn die Methode selber dennoch wartet?
ein Thread für sich ist doch kein Wundermittel sondern erfüllt nur seinen Zweck wenn eben die GUI tatsächlich keine Arbeit mehr hat

mal wieder einen lustigen Vergleich suchen:
der Chef will in den Urlaub fliegen, deshalb delegiert er seine Arbeit an Angestellte,
hat er Zeit gewonnen wenn er die ganze Zeit danebensitzt und auf das Ende der Arbeit wartet?

na, nicht so guter Vergleich, man könnte meinen er könnte die Zeit für anderes nutzen (die GUI etwa zum malen),
aber nein, warten ist genauso blockierend wie die die schwerste Arbeit,
es wird effektiv verhindert das Zeit für was anderes da ist

-------


> In der startUpload - Methode kann ich nicht mit sleep() warten, da diese Klasse kein Thread ist

sleep() ist eine statische Methode in Thread,
das eigene Thread-Objekt könnte man ansonsten übrigens auch überall erhalten: Thread.currentThread()

 

[filth]

Ok dann anders gefragt:
Wenn ich die Threads eliminiere - wie kann dann sichergestellt werden, dass der Fortschrittsbalken trotzdem gezeichnet wird und nicht die GUI während der Abarbeitung blockiert wird?

 

[SlaterB]

verwende z.B. folgendes:

public void startUpload()
    {
        // iterate over all selected events
        for (int i = 0; i < getEventList().size(); i++)
        {
            Event currentEvent = getEventList().get(i);
                        
            // process only events with added pics
            if(currentEvent.getEventPics().size() > 0)
            {
                PackUploader myPackuploader = new PackUploader( this, currentEvent );
                myPackuploader.uploadPics(); // kein Thread
                
                // kein Warten nötig
            }                                   
        }
    }

und die ganze Methode startUpload(), bzw. solle doUpload() heißen, gehört in die run-Methode eines Threads,
entweder einer neuen Klasse, man kann ruhig PackUploader doch wieder entsprechend hinbiegen,

oder anonym als Thread gestartet:

new Thread() {
  public void run() {
    doUpload()
  }
}.start();

benötigte Date wie getEventList() evtl. übergeben oder in der Methode am Anfang kopieren,
wenn der Thread Sekunden bis Minuten läuft wäre es vielleicht ungünstig wenn diese sich nebenher ändern..

 

[filth]

Passt 🙂