Thread XML-Dateien zusammenfügen

Adriano10

Bekanntes Mitglied
Auf dem SFTP-Server liegen über 500000 Dateien, die verarbeitet werden müssen, also pro Datei müssen 25000 zusammengefügt werden.

Ich habe mich für Thread entschieden, aber es ist sehr langsam, hätte jemand Optimierungsvorschläge? Im Umgang mit Thread bin ich so zu sagen Anfänger.

Mit besten Grüßen


Java:
   Vector<ChannelSftp.LsEntry> entries = sftp.ls(SOURCE);
        Lock sftpLock = new ReentrantLock();
        int numThreads = 4;
        int filesPerThread = entries.size() / numThreads;
        int remainingFiles = entries.size() % numThreads;

        Thread thread1 = new Thread(() -> {
            int startIndex = 0;
            int endIndex = filesPerThread;
            processXML(startIndex, endIndex, entries, sftp, sftpLock, xmlReadWriter111);
        });

        Thread thread2 = new Thread(() -> {
            int startIndex = filesPerThread;
            int endIndex = startIndex + filesPerThread;
            processXML(startIndex, endIndex, entries, sftp, sftpLock, xmlReadWriter111);
        });

        Thread thread3 = new Thread(() -> {
            int startIndex = 2 * filesPerThread;
            int endIndex = startIndex + filesPerThread;
            processXML(startIndex, endIndex, entries, sftp, sftpLock, xmlReadWriter111);
        });

        Thread thread4 = new Thread(() -> {
            int startIndex = 3 * filesPerThread;
            int endIndex = startIndex + filesPerThread + remainingFiles;
            processXML(startIndex, endIndex, entries, sftp, sftpLock, xmlReadWriter111);
        });

        thread1.start();
        thread2.start();
        thread3.start();
        thread4.start();

        thread1.join();
        thread2.join();
        thread3.join();
        thread4.join();

        sftp.disconnect();
        session.disconnect();
    }


    private static void processXML(int startIndex, int endIndex, Vector<ChannelSftp.LsEntry> entries, ChannelSftp sftp,
                                   Lock sftpLock, XMLReadWriter111 xmlReadWriter111) {
        List<Document> materials = new ArrayList<>();
        List<Document> erp_mark = new ArrayList<>();
        List<Document> crossreference = new ArrayList<>();
        List<Document> dokuinfosatz = new ArrayList<>();
        for (int k = startIndex; k < endIndex; k++) {
            ChannelSftp.LsEntry entry = entries.get(k);
            //Material"
            if (!entry.getAttrs().isDir() && entry.getFilename().startsWith("Material")) {
                String remoteFile = SOURCE + entry.getFilename();
                System.out.println(Thread.currentThread().getName() + " :" + k);
                try {
                    sftpLock.lock();
                    materials.add(parseXml(sftp.get(remoteFile)));
                } catch (SftpException e) {
                    e.printStackTrace();
                } finally {
                    sftpLock.unlock();
                }
            }

            if (materials.size() == 25000 && !materials.isEmpty()) {
                try {
                    sftpLock.lock();
                    xmlReadWriter111.createOneXMLFile(materials,
                            "C:\\Users\\test\\IdeaProjects\\XMLDateien\\xml", Tags.PRODUCTS.value());
                    materials.clear();
                } catch (Exception e) {
                    e.printStackTrace();
                } finally {
                    sftpLock.unlock();
                }
            }
            //ERP_MARKE
            if (!entry.getAttrs().isDir() && entry.getFilename().startsWith("ERP_MARKE")) {
                String remoteFile = SOURCE + entry.getFilename();
                System.out.println("B " + k);
                try {
                    sftpLock.lock();
                    erp_mark.add(parseXml(sftp.get(remoteFile)));
                } catch (SftpException e) {
                    e.printStackTrace();
                } finally {
                    sftpLock.unlock();
                }
            }

            if (erp_mark.size() == 25000 && !erp_mark.isEmpty()) {
                try {
                    sftpLock.lock();
                    xmlReadWriter111.createOneXMLFile(erp_mark,
                            "C:\\Users\\test\\IdeaProjects\\XMLDateien\\xml", Tags.PRODUCTS.value());
                    erp_mark.clear();
                } catch (Exception e) {
                    e.printStackTrace();
                } finally {
                    sftpLock.unlock();
                }
            }

            //Crossreference
            if (!entry.getAttrs().isDir() && entry.getFilename().startsWith("Crossreference")) {
                String remoteFile = SOURCE + entry.getFilename();
                System.out.println("Crossreference " + k);
                try {
                    sftpLock.lock();
                    crossreference.add(parseXml(sftp.get(remoteFile)));
                } catch (SftpException e) {
                    e.printStackTrace();
                } finally {
                    sftpLock.unlock();
                }
            }

            if (crossreference.size() == 25000 && !crossreference.isEmpty()) {
                try {
                    sftpLock.lock();
                    xmlReadWriter111.createOneXMLFile(crossreference,
                            "C:\\Users\\test\\IdeaProjects\\XMLDateien\\xml", Tags.PRODUCTS.value());
                    erp_mark.clear();
                } catch (Exception e) {
                    e.printStackTrace();
                } finally {
                    sftpLock.unlock();
                }
            }

            //Dokuinfosatz
            if (!entry.getAttrs().isDir() && entry.getFilename().startsWith("Dokuinfosatz")) {
                String remoteFile = SOURCE + entry.getFilename();
                System.out.println("Dokuinfosatz" + k);
                try {
                    sftpLock.lock();
                    dokuinfosatz.add(parseXml(sftp.get(remoteFile)));
                } catch (SftpException e) {
                    e.printStackTrace();
                } finally {
                    sftpLock.unlock();
                }
            }

            if (dokuinfosatz.size() == 25000 && !dokuinfosatz.isEmpty()) {
                try {
                    sftpLock.lock();
                    xmlReadWriter111.createOneXMLFile(dokuinfosatz,
                            "C:\\Users\\test\\IdeaProjects\\XMLDateien\\xml", Tags.ASSETS.value());
                    erp_mark.clear();
                } catch (Exception e) {
                    e.printStackTrace();
                } finally {
                    sftpLock.unlock();
                }
            }
        }

        if (!materials.isEmpty()) {
            try {
                sftpLock.lock();
                xmlReadWriter111.createOneXMLFile(materials,
                        "C:\\Users\\test\\IdeaProjects\\XMLDateien\\xml", Tags.PRODUCTS.value());
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                sftpLock.unlock();
            }
        }
        if (!erp_mark.isEmpty()) {
            try {
                sftpLock.lock();
                xmlReadWriter111.createOneXMLFile(erp_mark,
                        "C:\\Users\\test\\IdeaProjects\\XMLDateien\\xml", Tags.PRODUCTS.value());
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                sftpLock.unlock();
            }
        }

        if (!crossreference.isEmpty()) {
            try {
                sftpLock.lock();
                xmlReadWriter111.createOneXMLFile(crossreference,
                        "C:\\Users\\test\\IdeaProjects\\XMLDateien\\xml", Tags.PRODUCTS.value());
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                sftpLock.unlock();
            }
        }
        if (!dokuinfosatz.isEmpty()) {
            try {
                sftpLock.lock();
                xmlReadWriter111.createOneXMLFile(dokuinfosatz,
                        "C:\\Users\\test\\IdeaProjects\\XMLDateien\\xml", Tags.ASSETS.value());
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                sftpLock.unlock();
            }
        }
    }
 

Robert Zenz

Top Contributor
Naja, du machst ja auch viel innerhalb deiner Sperre, also solange eine Datei verarbeitet wird kann keine andere verarbeitet werden, damit bist du effektiv wieder einzelnen verarbeiten von einer Datei nach der anderen.

Du willst Dateien holen, und diese dann der Logik zufuehren. Oder, du holst die Datei und entsperrst dann dein SFTP wieder, und verarbeitest sie erst dann nachdem du das SFTP wieder freigegeben hast damit die naechste Datei schonmal geholt werden kann. Alternativ koenntest du auch mehrere SFTP Sitzungen verwenden, naemlich eine pro Thread, dann ist wirklich alles parallel.
 

Robert Zenz

Top Contributor
Also, du machst nicht alles innerhalb der Sperre, aber recht viel. Du solltest da zumindest holen und verarbeiten trennen so dass nur das Holen innerhalb der Sperre passiert, und alles andere nicht. Aber die beste Loesung waere mehrere SFTP-Verbindungen, eine pro Thread. Weil dann kannst du die wirklich parallel verarbeiten.
 

Adriano10

Bekanntes Mitglied
Also, du machst nicht alles innerhalb der Sperre, aber recht viel. Du solltest da zumindest holen und verarbeiten trennen so dass nur das Holen innerhalb der Sperre passiert, und alles andere nicht. Aber die beste Loesung waere mehrere SFTP-Verbindungen, eine pro Thread. Weil dann kannst du die wirklich parallel verarbeiten.
vielen Dank, probiere ich mall dann so, also du meinst ungefähr so?
Java:
        Thread thread1 = new Thread(() -> {
            int startIndex = 0;
            int endIndex = filesPerThread;
            Session session = jsch.getSession(username, remoteHost, 22);
            processXML(startIndex, endIndex, entries, sftp, sftpLock, xmlReadWriter111);
        });

        Thread thread2 = new Thread(() -> {
            int startIndex = filesPerThread;
            int endIndex = startIndex + filesPerThread;
            Session session = jsch.getSession(username, remoteHost, 22);
            processXML(startIndex, endIndex, entries, sftp, sftpLock, xmlReadWriter111);
        });

        Thread thread3 = new Thread(() -> {
            int startIndex = 2 * filesPerThread;
            int endIndex = startIndex + filesPerThread;
            Session session = jsch.getSession(username, remoteHost, 22);
            processXML(startIndex, endIndex, entries, sftp, sftpLock, xmlReadWriter111);
        });

        Thread thread4 = new Thread(() -> {
            int startIndex = 3 * filesPerThread;
            int endIndex = startIndex + filesPerThread + remainingFiles;
            Session session = jsch.getSession(username, remoteHost, 22);
            processXML(startIndex, endIndex, entries, sftp, sftpLock, xmlReadWriter111);
        });
 

Adriano10

Bekanntes Mitglied
Also, du machst nicht alles innerhalb der Sperre, aber recht viel. Du solltest da zumindest holen und verarbeiten trennen so dass nur das Holen innerhalb der Sperre passiert, und alles andere nicht. Aber die beste Loesung waere mehrere SFTP-Verbindungen, eine pro Thread. Weil dann kannst du die wirklich parallel verarbeiten.
also sftpLock.lock(); and sftpLock.unlock(); ist nicht mehr nötig oder?
 

Robert Zenz

Top Contributor
das ist gut aber, threads müssen auf gleiche Ressourcen in der Methode processXML zugreifen und daher ohne synchronisiere gibt es Lesekonflikt
Welche denn? Du definierst da ein paar Listen, aber keine davon werden auf irgendeine Art und Weise geteilt (sind nur in der Methode)?

Wenn dem so ist, musst du dir dann entweder eine feinere Zugriffskontrolle ueberlegen (so wenig Sperren wie moeglich), oder, ich weisz jetzt nicht wie genau deine Anforderung aussieht, du findest einen Weg jeden Thread fuer sich arbeiten zu lassen und dann die Ergebnisse zussamen zu fuehren.
 

KonradN

Super-Moderator
Mitarbeiter
Mir fällt es schwer, den ganzen Ansatz so nachzuvollziehen.

Ich bin ein Freund davon, dass man Code einfach hält. Du hast ein Vector mit den Einträgen - warum nicht einfach alles per parallelStream verarbeiten? Dann sparst Du Dir viel Code rund um Anzahl der Threads und deren Erzeugung. Die Java Runtime achtet dann darauf, dass du eine relativ optimale Anzahl Threads bekommst. Also bei vielen Cores hast Du mehr aktive Threads und so. Und ganz wichtig: Der Code wird einfacher!

Und dann wirklich die große Bitte: Schreibe sauberen Code!

a) doppelter Code! Du hast eine Variable mit Anzahl Threads und jeder Thread wird gleich erzeugt. Das schreit doch förmlich nach einer Schleife statt einfach nur Code mit Copy & Paste zu kopieren.

b) () -> { Wieso packst Du das aus dem Block nicht einfach in eine Methode und rufst diese dann auf? Lambda Expressions mit einem Block sind immer der Grund, wieso ich meine, dass statische Codeanalysetools eine tens unit brauchen um Entwicklern Stromstöße zu geben :) (Sorry, ist natürlich nur ein Spaß. Aber so manche Dinge machen Code wirklich nur unleserlich. Den Spaß bitte daher etwas verzeihen)

c) processXML - der Code geht von Zeile 46 bis 207. Muss ich da mehr zu schreiben?

Das wirkt sehr undurchdacht. Und ich habe da gewisse Probleme, die Motivation zu finden um da weiter drüber nach zu denken.


Dann evtl. noch eine Art minimales Connection Pooling. Die SSH Session würde ich also cachen. Dann kann jeder Aufruf einfach auf dem cache ein getSession() aufrufen und bekommt dann eine Instanz, die Autoclosable implementiert und eine Session kapselt. nach verwendung wird auf der Instanz ein close() aufgerufen so dass die Session für den nächsten Thread bereit steht. Ist relativ einfach und schnell umsetzbar denke ich.


Aber natürlich auch ganz wichtig: Was @Robert Zenz angesprochen hatte: Die Datenstruktur muss stimmig sein. Du hast irgend ein Aufbau mit
Java:
        List<Document> materials = new ArrayList<>();
        List<Document> erp_mark = new ArrayList<>();
        List<Document> crossreference = new ArrayList<>();
        List<Document> dokuinfosatz = new ArrayList<>();
Das scheinen irgendwelche zentralen Daten zu sein, die Du aufbauen willst. Das gehört in eine Klasse. Natürlich incl. der notwendigen Logik, die man da so braucht um Dinge hinzu zu fügen. Da wir über das fachliche nicht Bescheid wissen, können wir natürlich nichts sagen. Aber evtl. gibt es von einer Datei eine Referenz auf eine andere Datei, die noch nicht verarbeitet wurde. So Dinge muss man natürlich abdecken. Sowas will man dann ggf. einfügen incl. einem Vermerk, dass da noch die Basis fehlt. Dann hat man am Ende ggf. eine Liste mit Referenzen, die ins "Leere" zeigen oder so ... Aber das ist halt ein anderes Thema. Das ist etwas, das dann - sauber unterteilt in Klassen / Methoden erstellt werden muss.

Sowas im idealen Fall übrigens incl. UnitTests, die so fachliche Anforderungen auch testen. (Und die Unit Tests sind dann ein super Ort um die fachlichen Vorgaben zu dokumentieren mit JavaDoc Kommentaren :) )

Das einfach nur als ein paar allgemeine Informationen und Hinweise. Auch wenn dies womöglich nicht das direkte Kernproblem ansprechen, das Du lösen willst, hoffe ich doch sehr, dass diese allgemeinen Hinweisen dazu führen, dass Du besseren Code schreiben kannst, den Du dann auch einfacher selbst verstehen und ggf. anpassen kannst.
 

Adriano10

Bekanntes Mitglied
Mir fällt es schwer, den ganzen Ansatz so nachzuvollziehen.

Ich bin ein Freund davon, dass man Code einfach hält. Du hast ein Vector mit den Einträgen - warum nicht einfach alles per parallelStream verarbeiten? Dann sparst Du Dir viel Code rund um Anzahl der Threads und deren Erzeugung. Die Java Runtime achtet dann darauf, dass du eine relativ optimale Anzahl Threads bekommst. Also bei vielen Cores hast Du mehr aktive Threads und so. Und ganz wichtig: Der Code wird einfacher!

Und dann wirklich die große Bitte: Schreibe sauberen Code!

a) doppelter Code! Du hast eine Variable mit Anzahl Threads und jeder Thread wird gleich erzeugt. Das schreit doch förmlich nach einer Schleife statt einfach nur Code mit Copy & Paste zu kopieren.

b) () -> { Wieso packst Du das aus dem Block nicht einfach in eine Methode und rufst diese dann auf? Lambda Expressions mit einem Block sind immer der Grund, wieso ich meine, dass statische Codeanalysetools eine tens unit brauchen um Entwicklern Stromstöße zu geben :) (Sorry, ist natürlich nur ein Spaß. Aber so manche Dinge machen Code wirklich nur unleserlich. Den Spaß bitte daher etwas verzeihen)

c) processXML - der Code geht von Zeile 46 bis 207. Muss ich da mehr zu schreiben?

Das wirkt sehr undurchdacht. Und ich habe da gewisse Probleme, die Motivation zu finden um da weiter drüber nach zu denken.


Dann evtl. noch eine Art minimales Connection Pooling. Die SSH Session würde ich also cachen. Dann kann jeder Aufruf einfach auf dem cache ein getSession() aufrufen und bekommt dann eine Instanz, die Autoclosable implementiert und eine Session kapselt. nach verwendung wird auf der Instanz ein close() aufgerufen so dass die Session für den nächsten Thread bereit steht. Ist relativ einfach und schnell umsetzbar denke ich.


Aber natürlich auch ganz wichtig: Was @Robert Zenz angesprochen hatte: Die Datenstruktur muss stimmig sein. Du hast irgend ein Aufbau mit
Java:
        List<Document> materials = new ArrayList<>();
        List<Document> erp_mark = new ArrayList<>();
        List<Document> crossreference = new ArrayList<>();
        List<Document> dokuinfosatz = new ArrayList<>();
Das scheinen irgendwelche zentralen Daten zu sein, die Du aufbauen willst. Das gehört in eine Klasse. Natürlich incl. der notwendigen Logik, die man da so braucht um Dinge hinzu zu fügen. Da wir über das fachliche nicht Bescheid wissen, können wir natürlich nichts sagen. Aber evtl. gibt es von einer Datei eine Referenz auf eine andere Datei, die noch nicht verarbeitet wurde. So Dinge muss man natürlich abdecken. Sowas will man dann ggf. einfügen incl. einem Vermerk, dass da noch die Basis fehlt. Dann hat man am Ende ggf. eine Liste mit Referenzen, die ins "Leere" zeigen oder so ... Aber das ist halt ein anderes Thema. Das ist etwas, das dann - sauber unterteilt in Klassen / Methoden erstellt werden muss.

Sowas im idealen Fall übrigens incl. UnitTests, die so fachliche Anforderungen auch testen. (Und die Unit Tests sind dann ein super Ort um die fachlichen Vorgaben zu dokumentieren mit JavaDoc Kommentaren :) )

Das einfach nur als ein paar allgemeine Informationen und Hinweise. Auch wenn dies womöglich nicht das direkte Kernproblem ansprechen, das Du lösen willst, hoffe ich doch sehr, dass diese allgemeinen Hinweisen dazu führen, dass Du besseren Code schreiben kannst, den Du dann auch einfacher selbst verstehen und ggf. anpassen kannst.
hier gebe ich vollkommen Recht, ich achte immer auch möglicherweise auf Codequalität, aber das ist keine fertiges Code, ich hatte nur angefangen, wenn es läuft, danach mache ich immer Verbesserung
 

KonradN

Super-Moderator
Mitarbeiter
hier gebe ich vollkommen Recht, ich achte immer auch möglicherweise auf Codequalität, aber das ist keine fertiges Code, ich hatte nur angefangen, wenn es läuft, danach mache ich immer Verbesserung
Das ist etwas, das durchaus normal ist. Aber meine Erfahrung hat recht deutlich gezeigt, dass es deutlich besser ist, wenn man von Anfang an entsprechend strukturiert. Alleine schon, um auch von Anfang an mit Unit Tests zu arbeiten.

Klar, wenn man etwas ausprobiert, dann sind die Unit Tests keine wirklichen Unit Tests. Dann greift man auf einen SSH Server zu und arbeitet da mit Dateien oder so. Aber dennoch strukturiert man alles etwas.

Gerade bei so Dingen, die schnell etwas komplexer werden, ist man dann unter dem Strich deutlich schneller unterwegs.

Und man hat immer das Risiko, dass Du so eine Methode hast, die erst einmal macht, was sie soll. Das Umschreiben dazu fehlt die Zeit und schon hast Du einen Code wie das processXML in Produktion. Das ist dann eine (annähernd) ungetestete Methode und es ist nur eine Frage der Zeit, bis es notwendig wird, da Änderungen dran vorzunehmen. Oder in 1 Jahr oder so mal überlegen, was die genauen Spezifikationen waren, die da umgesetzt wurden :)

(Und wie wichtig so Dinge sind, merkst Du, wenn Du in einem Projekt bist, das seit > 30 Jahren läuft. Das geht nur mit sehr hoher Code Qualität. Einiges ist aus heutiger Sicht nicht gut, aber die damalige, hohe Qualität hat dazu geführt, dass die Software auch nach all diesen Jahrzehnten noch immer angepasst werden kann und immer noch stabil im Betrieb ist. Und das ohne wirkliche Ausfälle in Produktion - was wichtig ist, denn an gewisser Software hängt ggf. auch mit die Existenz eines Konzerns :) )
 
Ähnliche Java Themen
  Titel Forum Antworten Datum
Leyla Thread isInterrupt Java Basics - Anfänger-Themen 18
P Meldung aus Java-Klasse in Thread an aufrufende Klasse Java Basics - Anfänger-Themen 1
F influxdb Upload in eigenem Thread Java Basics - Anfänger-Themen 2
frager2345 Thread - Methoden synchronized deklarieren Java Basics - Anfänger-Themen 10
berserkerdq2 Größter unterschied von extends thread und implements runnable? Java Basics - Anfänger-Themen 2
T Thread beenden aus zweiter Klasse Java Basics - Anfänger-Themen 4
A Thread - Synchronized Java Basics - Anfänger-Themen 10
A Thread Producer - Consumer Java Basics - Anfänger-Themen 1
A Thread-Semhapore Java Basics - Anfänger-Themen 0
A Thread Exchanger Java Basics - Anfänger-Themen 22
A Thread-Cyclicbarrier Java Basics - Anfänger-Themen 4
B In einem Thread Endlosschleife beenden Java Basics - Anfänger-Themen 19
A Thread-Verklemmung Java Basics - Anfänger-Themen 10
A Thread-Schreibe-Lese-Problem Java Basics - Anfänger-Themen 4
A Thread find number Java Basics - Anfänger-Themen 8
F Thread.sleep() Java Basics - Anfänger-Themen 5
F Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 11 at main.main(main.java:11) Java Basics - Anfänger-Themen 2
A Thread Java Basics - Anfänger-Themen 3
M Exception in thread "main" java.util.NoSuchElementException Java Basics - Anfänger-Themen 2
A Thread Java Basics - Anfänger-Themen 8
B Compiler-Fehler Fehlermeldung Exception in thread, falsche Eingabewert Java Basics - Anfänger-Themen 2
M Thread-Zustände Java Basics - Anfänger-Themen 6
CptK For-Schleife in Thread nach jedem Durchlauf pausieren Java Basics - Anfänger-Themen 35
S Kriege Fehler "Exception in thread" beim Benutzen von SubStrings. Java Basics - Anfänger-Themen 2
B Endlosschleife Thread sauber beenden Java Basics - Anfänger-Themen 19
D Java Thread wartet nur ein mal Java Basics - Anfänger-Themen 1
D Java Thread wartet nur ein mal Java Basics - Anfänger-Themen 0
O Exception in thread "main" java.lang.ArithmeticException: / by zero Java Basics - Anfänger-Themen 4
C Thread und TimerTask, Verstädnisproblem Java Basics - Anfänger-Themen 10
amgadalghabra Sorting Thread Launcher Java Basics - Anfänger-Themen 3
B Exception in thread "AWT-EventQueue-0" java.util.ConcurrentModificationException Java Basics - Anfänger-Themen 8
A Thread Java Basics - Anfänger-Themen 4
A Thread Java Basics - Anfänger-Themen 1
A Thread Java Basics - Anfänger-Themen 0
R Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException Java Basics - Anfänger-Themen 5
S Compiler-Fehler Exception in thread "main" java.lang.Error: Unresolved compilation problem: Java Basics - Anfänger-Themen 6
L Liste in anderem Thread laden Java Basics - Anfänger-Themen 1
B Thread / Prozess stoppen? Java Basics - Anfänger-Themen 22
I Compiler-Fehler Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 5 Java Basics - Anfänger-Themen 3
B Threads Thread sleep() Method einfache Frage Java Basics - Anfänger-Themen 8
W Thread Aufgabe - Vorgehensweise Java Basics - Anfänger-Themen 8
L Liste in anderem Thread laden Java Basics - Anfänger-Themen 0
J Threads PrograssBar update während thread Java Basics - Anfänger-Themen 13
D Compiler-Fehler Wert auf Datenbank übertragen und Sleep Thread Java Basics - Anfänger-Themen 3
Spencer Reid JavaFX Memory Thread.sleep Java Basics - Anfänger-Themen 1
S Thread.sleep mit JProgressBar Java Basics - Anfänger-Themen 1
ralfb1105 Frage zu Thread Synchronisation mit wait() und notify() Java Basics - Anfänger-Themen 3
R Exception in thread "main" java.lang.NullPointerException Java Basics - Anfänger-Themen 10
J JavaFX -> SocketIO -> Thread -> Update Label Java Basics - Anfänger-Themen 13
J Thread Handling Java Basics - Anfänger-Themen 9
A Problem mit Thread.sleep Java Basics - Anfänger-Themen 4
C Thread in Methode + raus aus der Schleife Java Basics - Anfänger-Themen 10
E Threads Thread in While-Schleife nur einmal starten Java Basics - Anfänger-Themen 2
F Daten von Thread an den aufrufenden zurückgeben Java Basics - Anfänger-Themen 22
C Compiler-Fehler Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 2 Java Basics - Anfänger-Themen 3
B Thread Problem Java Basics - Anfänger-Themen 7
N KeyListener in Thread Java Basics - Anfänger-Themen 0
M Thread.sleep() Funktion Java Basics - Anfänger-Themen 1
W JLabel in Main aus Thread verändern. Java Basics - Anfänger-Themen 4
D Ausgeben welcher Thread gerade Arbeitet Java Basics - Anfänger-Themen 8
N Threads Thread-Fehler Java Basics - Anfänger-Themen 2
F Thread um Uhrzeit ausführen Java Basics - Anfänger-Themen 5
F Get/Post als eigener Thread mit Rückgabe Java Basics - Anfänger-Themen 5
J Exception in thread "main" Java Basics - Anfänger-Themen 1
F Thread der auf eine Queue wartet, sicher beenden Java Basics - Anfänger-Themen 4
B Animation mit Thread(s) Java Basics - Anfänger-Themen 23
I Thread.sleep (1000); Java Basics - Anfänger-Themen 1
M Threads Jede Klasse einem Thread zuweisen Java Basics - Anfänger-Themen 7
J Java Thread cancel() und wiederbeleben Java Basics - Anfänger-Themen 4
J BouncingBalls 1 Thread Java Basics - Anfänger-Themen 3
L Fehler: Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException Java Basics - Anfänger-Themen 4
J Timer oder Thread programmieren ? Java Basics - Anfänger-Themen 10
fLooojava Laufender Thread | Boolean ändern Java Basics - Anfänger-Themen 9
T Thread Pool mit Work Stealing Java Basics - Anfänger-Themen 1
R Java Thread Java Basics - Anfänger-Themen 10
J Welche Methoden laufen im neuen thread ?? Java Basics - Anfänger-Themen 9
S Java memory fehler: Exception in thread "AWT-EventQueue-0" java.lang.OutOfMemoryError: Java heap spa Java Basics - Anfänger-Themen 5
K Thread - Methoden in die run Methode Schreiben Java Basics - Anfänger-Themen 5
N Threads Exception in thread "main"... Feher bei dem Versuch ein Radius zu berechnen Java Basics - Anfänger-Themen 4
A Code läuft nicht, Fehlermeldung Exception in thread "main" java.lang.Error: Unresolved compilation " Java Basics - Anfänger-Themen 11
V Threads Exception in Thread behandeln Java Basics - Anfänger-Themen 3
S Methoden Multi-Thread und Methoden Objects. Java Basics - Anfänger-Themen 1
J Thread erstellen (BlueJ Projekt) Java Basics - Anfänger-Themen 3
P Exception in thread "main" java.lang.NoClassDefFoundError: Java Basics - Anfänger-Themen 1
F Threads Variable aus einem Thread in main Methode? Java Basics - Anfänger-Themen 9
K Exception in thread "main" Java Basics - Anfänger-Themen 7
L Thread-Frage Java Basics - Anfänger-Themen 2
E Was ist ein idle-thread? Java Basics - Anfänger-Themen 1
D Exception in thread "AWT-EventQueue-0" Java Basics - Anfänger-Themen 8
J Threads Prozess in Thread auslagern Java Basics - Anfänger-Themen 2
G Thread mehrmals starten und schliessen Java Basics - Anfänger-Themen 6
F Thread Koordination (Vorteile/Nachteile) Java Basics - Anfänger-Themen 0
O Thread aus dem Thread stoppen Java Basics - Anfänger-Themen 6
O Swingworker/Thread Java Basics - Anfänger-Themen 3
R Focus auf JPanel im Thread Java Basics - Anfänger-Themen 9
S musik in eigenem thread Java Basics - Anfänger-Themen 2
A Klasse,Vererbung,Interface,Singleton,Thread Java Basics - Anfänger-Themen 5
IngoF GUI mit Thread Daten austauschen. Java Basics - Anfänger-Themen 6
L Compiler-Fehler Exception in thread "main" java.lang.NullPointerException Java Basics - Anfänger-Themen 2
F Exception in thread main java.lang.StackOverflowError Java Basics - Anfänger-Themen 3

Ähnliche Java Themen

Neue Themen


Oben