Concurrent Thema

[Fohnbit]

Hallo,

ich habe in meiner Klasse:
List
ArrayList
LimitedQueue
LinkedList

Ich hatte einmal die Exception: java.util.ConcurrentModificationException

Meine Frage nun:
Wenn Methoden in meiner Klasse, die andere Threads aufrufen, auf die Variablen zugreifen ... ist sicher gestellt, das keine 2 Methoden zur selben Zeit laufen?

So wird zum Beispiel in einer Methode über einen Loop die LimidetQueue gefüllt.
Und es kann sein das ein Thread über eine andere Methode auch etwas in die Queue legt.

Können also 2 Methoden in der selben Klasse gar nie zeitgleich laufen, oder muss man das irgendwie abfangen?

Danke!

 

[Xyz1]

Wie wär's mit Thread-sicheren Collections?

 

[stg]

Wenn Methoden in meiner Klasse, die andere Threads aufrufen, auf die Variablen zugreifen ... ist sicher gestellt, das keine 2 Methoden zur selben Zeit laufen?

Zwei Threads laufen unabhängig voneinander und können, sofern beide Kenntnis von den selben daten haben, auch zeitgleich auf die selben Daten zugreifen. Das musst du, sofern es dadurch zu Problemen kommen kann natürlich unterbinden.

 

[Fohnbit]

Die anderen Threads greifen nicht direkt auf die Listen zu. Sie rufen eine Methode auf und übergeben darin die nötigen Parameter. Die Methode in der selben Klasse legt dann die Infos in die Liste.

Ich habe inzwischen "CopyOnWriteArrayList" gefunden ... wäre das für die Listen passend?

 

[Fohnbit]

Anbei noch 2 Methoden die die Listen beeinflussen:

    @Override
    public void getStatus(int responseCode, String value) {

        if (responseCode == HttpURLConnection.HTTP_UNAUTHORIZED) {
            updateOutputUploadresponse("Fehler beim upload. Authentifizierungsfehler. Falscher Apikey? Error Code: "
                    + responseCode);
            failedUploads1.add(value);
            updateOutputUploadbuffer(failedUploads1.size());
        } else if (responseCode == HttpURLConnection.HTTP_OK) { // success
            updateOutputUploadresponse("Upload OK!");
        } else {
            updateOutputUploadresponse("Fehler beim upload. Error Code: "
                    + responseCode);
            failedUploads1.add(value);
            updateOutputUploadbuffer(failedUploads1.size());
        }

    }

    @Override
    public void getStatus(String error, LimitedQueue<String> data) {
        updateOutputUploadresponse("Fehler beim upload. Error Code: " + error);
        System.out.println("Fehler beim Upload: " + error);
        for (String s : data) {
            System.out.println("Gescheiterter Upload: " + s);
        }
        failedUploads1.addAll(data);
        System.out.println("Data Size: " + data.size());
        System.out.println("Failedupload Size: " + failedUploads1.size());
        updateOutputUploadbuffer(failedUploads1.size());

    }

Die Listen Deklaration:

    private LimitedQueue<String> failedUploads1 = new LimitedQueue<String>(
            10000);

Und die Queue Klasse selbst:

public class LimitedQueue<E> extends LinkedList<E> {

    /**
     *
     */
    private static final long serialVersionUID = -4649076009250033576L;
    private int limit;

    public LimitedQueue(int limit) {
        this.limit = limit;
    }

    @Override
    public boolean add(E o) {
        boolean added = super.add(o);
        while (added && size() > limit) {
            super.remove();
        }
        return added;
    }
}

 

[stg]

Das ist denkbar, aber auch schon ein recht "schweres Geschütz".
Eine allgemeingültige Antwort gibt es nicht, das hängt immer von vielen Faktoren ab. Zum Beispiel Anzahl an lesenden/schreibenden Zugriffen usw.
Denkbar ist auch einfach ein synchronized Block, aber das kann auch schnell zum Nadelör werden.
Denkbar sind ferner auch Locks.

 

[Andy17]

Concurrent Computing ist eher ein Thema für Fortgeschrittene. Wie oben beschrieben spielen viele Faktoren eine Rolle bei der Wahl eines Lösungsansatzes. Erstmalig funktionieren werden alle oben genannten Ansätze. Du kannst jedoch in verschiedene Probleme laufen, selbst wenn Du RaceConditions ausschließen kannst.
Ich würde Dir empfehlen, Dir erstmal etwas Literatur zu Concurrent Computing durchzulesen und dann zu überlegen, wie kritisch deine Operationen sind (Anzahl Zugriffe lesender und schreibender Art) und dann selbst eine Vorgehensweise wählen.