Afvikle sekvens af metode-kald, der venter på hinanden

semaphor maaske ?

->arne_v: Det må du lige uddybe :-)

Java 1.5 se java.util.concurrent.Semaphore

for aeldre jaba versioner har jeg noget liggende

teknikken er at en traad hapser semaphoren og en anden traad venter paa semaphoren
indtil den foerste traad frigiver  den

->arne_v: Den nemme måde er at placere alle metode-kaldene i completed() og kombinere med en tæller, der udfører dem en efter en, idet completed() netop venter på "completion". Altså noget med:

int count=0;
if (count==0) myclass.loadPage("http://www.minside1.com");
else
if (count==1) myclass.loadPage("http://www.minside2.com");
else
if (count==2) myclass.loadPage("http://www.minside3.com");
else
...
count++;

Hovedprogrammet skal så lige starte med at fyre en event af, så completed() kaldes første gang, alternativt skal første kald være i hovedprogrammet. Koden kan gøres noget pænere men tankegangen er den samme.

Jeg vil dog se lidt på Semaphore; det lyder interessant. Smid gerne et svar.

jeg tror at semaphore loesningen kan laves paenere

->arne_v: Hvis du har noget liggende, må du gerne smide det ind. Om ikke andet læser jeg selv lidt videre på lektien :-) Skriver du i øvrigt fra udlandet?

public class Semaphore {
    private boolean inuse;
    private int counter;

    public Semaphore() {
        inuse = false;
        counter = 0;
    }

    public synchronized void get() {
        counter++;
        while (inuse) {
            try {
                wait();
            } catch (InterruptedException e) {
                // ignore
            }
        }
        inuse = true;
        counter--;
    }

    public synchronized void release() {
        inuse = false;
        notify();
    }
    public synchronized boolean available() {
        return inuse;
    }
    public synchronized int waiting() {
        return counter;
    }
    public static void main(String[] args) {
        long start = System.currentTimeMillis();
        Semaphore sem = new Semaphore();
        MyThread[] t = new MyThread[10];
        for(int i = 0; i < t.length; i++) {
            t[i] = new MyThread(sem);
        }
        for(int i = 0; i < t.length; i++) {
            t[i].start();
        }
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e1) {
            // ignore
        }
        System.out.println("Waiting=" + sem.waiting());
        for(int i = 0; i < t.length; i++) {
            try {
                t[i].join();
            } catch (InterruptedException e) {
                // ignore
            }
        }
        long end = System.currentTimeMillis();
        System.out.println("Time=" + (end - start));
    }

}
class MyThread extends Thread {
    private Semaphore sem;
    public MyThread(Semaphore sem) {
        this.sem = sem;
    }
    public void run() {
        sem.get();
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            // ignore
        }
        sem.release();
    }
}

der er som sagt en Semaphore klasse indbygget i 1.5

jeps - jeg sidder i udlandet