Thread-Cyclicbarrier

[Adriano10]

Moin,
also meine Aufgabe ist folgende:

Die Klasse Sammelpunkt kann zur Umsetzung von Sammelpunkten für mehrere Threads eingesetzt werden. Im Konstruktor wird dazu die Anzahl N an teilnehmenden Threads angegeben. Ruft ein Thread die Methode warten auf, wird er solange blockiert, bis diese Methode auch von den anderen Threads aufgerufen wurde. Ruft der N-te Threads die Methode auf, werden alle am Sammelpunkt wartenden Threads deblockiert und alle Threads können weiterarbeiten. Das Treffen der N Threads an Sammelpunkten soll sich zyklisch wiederholen können.


Ich wollte gern fragen, ob mein Code die Bedingungen erfüllt, wenn nicht, was soll ich dann noch machen.

Vielen Dank im Voraus.

public class Sammelpunkt extends CyclicBarrier {

    public Sammelpunkt(int anzahl) {
        super(anzahl);
    }

    public void warten() throws InterruptedException, BrokenBarrierException {
        Thread.sleep(1000);
        int await = this.await();
        if (await == 0) {
            System.out.println("############");
        }
    }
}

class Worker implements Runnable {
    Sammelpunkt sammelpunkt;

    public Worker(Sammelpunkt spammers) {
        this.sammelpunkt = spammers;
    }

    @Override
    public void run() {
        System.out.println("1. " + Thread.currentThread().getName());
        try {
            Thread.sleep(1000);
            sammelpunkt.warten();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (BrokenBarrierException e) {
            e.printStackTrace();
        }
        System.out.println("2. " + Thread.currentThread().getName());
    }
}

class Main {
    public static void main(String[] args) {
        Sammelpunkt sammelpunkt = new Sammelpunkt(3);
        Worker worker = new Worker(sammelpunkt);
        new Thread(worker, "Thread-1").start();
        new Thread(worker, "Thread-2").start();
        new Thread(worker, "Thread-3").start();
    }
}

 

[mihe7]

Sagen wir mal so: rein vom Lesen dürfte der Code funktionieren. Abgesehen von der Frage, was das sleep und die Ausgabe in Sammelpunkt#warten soll, frage ich mich allerdings, ob es Sinn der Aufgabe sein kann, per Ableitung einfach eine bestehende Klasse und Methode umzubenennen. Zusammengestrichen schaut Deine Klasse ja so aus:

public class Sammelpunkt extends CyclicBarrier {

    public Sammelpunkt(int anzahl) {
        super(anzahl);
    }

    public void warten() throws InterruptedException, BrokenBarrierException {
        this.await();
    }
}

Ich hätte vermutet, dass Du selbst CyclicBarrier implementieren sollst aber das kann ich nicht beurteilen.

 

[Adriano10]

Sagen wir mal so: rein vom Lesen dürfte der Code funktionieren. Abgesehen von der Frage, was das sleep und die Ausgabe in Sammelpunkt#warten soll, frage ich mich allerdings, ob es Sinn der Aufgabe sein kann, per Ableitung einfach eine bestehende Klasse und Methode umzubenennen. Zusammengestrichen schaut Deine Klasse ja so aus:

public class Sammelpunkt extends CyclicBarrier {

    public Sammelpunkt(int anzahl) {
        super(anzahl);
    }

    public void warten() throws InterruptedException, BrokenBarrierException {
        this.await();
    }
}

Ich hätte vermutet, dass Du selbst CyclicBarrier implementieren sollst aber das kann ich nicht beurteilen.

ja, ich habe mir auch gedacht, ich versuche mal selbst CyclicBarrier zu implementieren.

 

[Adriano10]

public class Sammelpunkt {
    int anzahl;
    int threadAwait;
    private Object object;

    public Sammelpunkt(int anzahl, Object ob) {
        this.anzahl = anzahl;
        this.threadAwait = anzahl;
        this.object = ob;
    }

    public synchronized void warten() throws InterruptedException {
        threadAwait--;
        if (threadAwait > 0) {
            this.wait();
        } else {
            threadAwait = anzahl;
            notifyAll();
        }
    }
}

class Main {
    public static void main(String[] args) {
        Object ob = new Object();
        Sammelpunkt sammelpunkt = new Sammelpunkt(3, ob);
        System.out.println("CountDownLatch has been created with parties=3," + " when all 3 parties will reach common barrier point " +
                           "CyclicBarrrierEvent will be triggered");

        Worker worker = new Worker(sammelpunkt);

        new Thread(worker, "Thread-1").start();
        new Thread(worker, "Thread-2").start();
        new Thread(worker, "Thread-3").start();

    }
}

class Worker implements Runnable {

    Sammelpunkt sammelpunkt;

    Worker(Sammelpunkt cyclicBarrierCustom) {
        this.sammelpunkt = cyclicBarrierCustom;
    }

    @Override
    public void run() {

        System.out.println(Thread.currentThread().getName() + " Wartet");

        try {
            Thread.sleep(1000);
            sammelpunkt.warten();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + " wurde freigegeben");
    }

}

Aber Ausgabe habe ich immer unterschiedlich
z.B
Thread-1 warten
Thread-2 warten
Thread-3 warten

Thread-2 freigeben
Thread-1 freigeben
Thread-3 freigeben

Ich denke, muss so ausgegeben werden
Thread-1 warten
Thread-2 warten
Thread-3 warten

Thread-1 freigeben
Thread-2 freigeben
Thread-3 freigeben

 

[mihe7]

Aber Ausgabe habe ich immer unterschiedlich

Das ist bei Parallelverarbeitung relativ normal.