Was ist sinnvoller? Global oder Instance?

Hi ihr,
ich frage mich, ob ich eine Globale Klasse die in jedem Thread gebraucht wird als Instance übergeben soll oder einfach Global darauf zugreifen soll?

Undzwar ist die Frage, wie gesagt, auf Threads bezogen.

Also :

public static void main(String[] args) {
        RandomKlasse klasse = new RandomKlasse();
        while(an) {
            if (neuesthread()) {
                RandomThread dasthread = new RandomThread(klasse);
            }
        }
    }

    //in dem Thread wird mit der Instance gearbeitet
public class RandomThread extends Thread {
    RandomKlasse rand;
    public RandomThread(RandomKlasse klasse) {
        this.rand = klasse;
    }

    public void run() {
        System.out.println(rand.getText());
    }
}

oder

public static RandomKlasse klasse = new RandomKlasse();

    public static void main(String[] args) {
        while(an) {
            if (neuesthread()) {
                RandomThread dasthread = new RandomThread();
            }
        }
    }

    //in dem Thread wird mit der Instance gearbeitet
public class RandomThread extends Thread {

    public void run() {
        System.out.println(Main.klasse.getText());
    }
}

MfG,
LilaLisa

Das Kommentar im 2tem Code-Ausschnitt ist natürlich falsch.

Richtig wäre:

//in diesem Thread wir mit der Globalen Klasse gearbeitet

MfG,
LilaLisa

Tut mir leid das mein Post leich unüberdacht war.

Habe noch vergessen hinzuzufügen, dass es um die 200~ Threads später gibt und diese auch für längere Zeit, bzw. oft auf diese Klasse zugreifen.

MfG,
LilaLisa

Ravendark

Wenn du eine statische globale Klasseninstanz benutzt, greifen alle 200 Threads auf dieses eine Objekt zu,
dann musst du dich um synchronisierten Zugriff auf die dort gespeicherten geteilten Ressourcen kümmern.

Wenn du jedem Thread ein neues Objekt übergibts, arbeitet jeder Thread mit einem neuen (eigenen) Objekt.

x4u

So wie ich die Frage verstehe wird sowieso in beiden Fällen jeweils nur eine Instanz von RandomKlasse erzeugt und dann von allen Threads verwendet? Zumindest ist es so in den beiden Beispielen implementiert. In diesem Fall ist es hauptsächlich eine kosmetische Entscheidung, was dir besser gefällt. Wenn du die Referenz auf die Instanz im Konstruktor übergibst, kannst du sicher sein, dass sie sich für die Lebensdauer des Threads nicht mehr ändert. Umgekehrt könntest die globale Referenz irgenwann mal austauschen wollen und alle Threads würden von da an automatisch die neue Instanz verwenden. Kommt halt drauf an welches Verhalten du brauchst.

Der zusätzliche Speicherplatz, den die Referenz in den Threadobjekten belegt ist im Vergleich zu dem was ein Thread-Objekt selbst an Speicher belegt vernachlässigbar.

200 Threads laufen zu lassen ist generell keine gute Idee, jedenfalls nicht solange du nicht wenigstens ca. 100 CPU-Cores im Rechner hast. Die vielen Threads behindern sich nur gegenseitig und verbrauchen riesige Mengen Speicher (Minimum ca. ein halbes MB pro Thread, macht alleine 100 MB nur für die Existenz der Threads). Besser ist es meistens in solchen Fällen eine Jobqueue zu implementieren und diese dann mit ein paar (ca. 2x CPU-Coreanzahl) Workerthreads der Reihe nach abzuarbeiten. Das ist in der Regel deutlich effizienter und skaliert auch noch besser als für jeden Job einen eigenen Thread anzulegen. Zumal das Erzeugen und spätere Freigeben von Threads auch sehr teuer ist und damit erheblich Performance kostet wenn die Jobs nur sehr kurz laufen.