Schnellste Methode, ein Array durchzugehen?

[NicoHatProbleme2]

Hallo,

Ich wollte eine Klasse erstellen, in der man einen Pixelartigen Bildschirm hat... Dafür habe ich einen array benutzt. Jetzt ist aber die Frage, wie ich das am schnellsten durchlaufen kann.
Ich habe jetzt schon das einfache Durchlaufen durch Threads verschnellert, ist aber immer noch nicht genug.

public void drawPixels() {
        for(int i = 0; i < pixel.length; i++) {
            PixelThread thread = new PixelThread();
            thread.start();
            thread.split(i, pixel);
            /**
            for(int j = 0; j < pixel[i].length; j++) {
                pixel[i][j][0].clear();
                for(int k = 0; k < pixel[i][j].length; k++) {
                    if(visible) pixel[i][j][k].draw();
                }
            }
            **/
        }
    }
    private class PixelThread extends Thread {
        public void run() {
            
        }
        public void split(int i, Pixel[][][] pixel) {
            for(int j = 0; j < pixel[i].length; j++) {
                pixel[i][j][0].clear();
                for(int k = 0; k < pixel[i][j].length; k++) {
                    if(visible) pixel[i][j][k].draw();
                }
            }
        }
    }

 

[LimDul]

Hallo,

Ich wollte eine Klasse erstellen, in der man einen Pixelartigen Bildschirm hat... Dafür habe ich einen array benutzt. Jetzt ist aber die Frage, wie ich das am schnellsten durchlaufen kann.
Ich habe jetzt schon das einfache Durchlaufen durch Threads verschnellert, ist aber immer noch nicht genug.

Nein hast du nicht.

Deine Threads machen genau gar nichts.
Du führst alles in einem thread aus. thread.start(); sorgt dafür, dass die Methode run des Threads in einem eigenen Thread ausgeführt wird. Diese Methode macht bei dir genau gar nichts. Die Split Methode wird weiterhin im Hauptthread nur durchlaufen. Du müsstest einen Code in die run Methode verlagern (Oder besser nicht von Thread erben, sondern von Runnable und das erzeugte Runnable Objekt an einen Thread übergeben - das wäre sauberer)

 

[NicoHatProbleme2]

Muss ich dann in split() nur i und pixel übergeben? (und split vor start ausführen)

 

[KonradN]

Wenn Du von Thread abeitest und dann eine Instanz erzeugst und start() aufrufst, dann läuft das, was in run() steht, in dem Thread. run ist aber leer und macht nichts. Also machst Du nichts in irgend welchen anderen Threads!

            PixelThread thread = new PixelThread(); // Hier erzeugst Du eine neue Instanz ...
            thread.start(); // Jetzt wird in einem anderen Thread die run() Methode gestartet
            thread.split(i, pixel); // Auf dem Thread, der halt alle diese Befehle ausgeführt wurde, wird split gemacht.

Also einfach noch einmal das Thema Threads selbst noch einmal durchgehen.

Oder ggf. ist es auch eine Alternative, das z.B. mit Streams zu machen und dann parallele Streams zu verwenden.

 

[Neumi5694]

Auf die Frage zur Geschwindigkeit zurückzukommen. Mit for-each oder for-to bist du bei sequentieller Abarbeitung schon ganz gut dabei.
Streams sind im Vergleich arschlangsam, die nur dann verwenden, wenn parallel gearbeitet werden soll. Und auch dann bringt's im Normalfall nur was, wenn die Ausführungszeit jeder Aktion hoch genug ist. Bei einer einfachen Abfrage/Zuweisung-Operation frisst die Verwaltung der Threads viel mehr Zeit, als man durch die Parallelisierung gewinnt.
Auch wenn die verschiedenen Threads eine gemeinsame langsame Komponente haben wie den Zugriff auf's Filesystem, ist der Vorteil dahin, aber in dem speziellen Fall ist es komplett egal, was man macht, was die Geschwindigkeit ausbremst, hat nichts mit der Schleife zu tun.

 

[NicoHatProbleme2]

Auf die Frage zur Geschwindigkeit zurückzukommen. Mit for-each oder for-to bist du bei sequentieller Abarbeitung schon ganz gut dabei.
Streams sind im Vergleich arschlangsam, die nur dann verwenden, wenn parallel gearbeitet werden soll. Und auch dann bringt's im Normalfall nur was, wenn die Ausführungszeit jeder Aktion hoch genug ist. Bei einer einfachen Abfrage/Zuweisung-Operation frisst die Verwaltung der Threads viel mehr Zeit, als man durch die Parallelisierung gewinnt.
Auch wenn die verschiedenen Threads eine gemeinsame langsame Komponente haben wie den Zugriff auf's Filesystem, ist der Vorteil dahin, aber in dem speziellen Fall ist es komplett egal, was man macht, was die Geschwindigkeit ausbremst, hat nichts mit der Schleife zu tun.

Soll das heißen, dass das mit dem Thread nur langsamer macht?

 

[Neumi5694]

Nein, damit hat's nicht viel zu tun. Ein Thread ändert nichts ander Geschwindigkeit.
Dein Thread wird weder etwas schneller noch etwas langsamer machen, er wird dazu führen, dass die Aktion im Hintergrund stattfindet, während das Programm weiterlaufen kann.

Was ich meinte, war das:

Point[] points = ...;
//for-each, geht bei Arrays und Listen recht schnell
for (var p : points) {
    p.setLocation(p.getX()+1,p.getY()); //Kurze Operation, braucht kaum Rechnezeit
}

//Alternative mit sequentiellem Stream, sehr sehr langsam im Vergleich
Arrays.stream(points).forEach( p-> p.setLocation(p.getX()+1,p.getY()));

//Alternative mit parallelem Stream. Es werden zwar mehrere Punkte gleichzeitig verändert, die Verwaltung der Threads und des Streams hebt diesen Vorteil aber wieder auf.
Arrays.asList(points).parallelStream().forEach( p-> p.setLocation(p.getX()+1,p.getY()));

 

[NicoHatProbleme2]

irgendwie macht es das Programm sogar langsamer

 

[Jw456]

Hallo mit deinem Algorithmus wirst du auch nicht schneller werden.

Du geht ja auch wenn du 10 Threads benutzt jedes Pixel von deinem Array durch.

Um Geschwindigkeit zugewinnen musst du das schon sinnvoll aufteilen so das nicht jeder Thread alles bearbeitet.

Wenn der erste Thread zb den ersten Teil des Arrays durchgeht und ein zweiter den zweiten Teil des Arrays, dann wird das schneller werden. Wenn jeder Thread immer alles macht bestimmt nicht.

Wenn zwei Mann einen Sandhaufen umschaufeln. Bearbeiten beide ja nur die Hälfte von Ganzen.

 

[Neumi5694]

class MyThread extends Thread{
    private E[] myArray;
    MyThread(E[] array) {
        this.myArray = array;
    }
    public void run() {
        doSomethingImportantWithMyArray();
    }
    private void doSomethingImportantWithMyArray() {
        //...
    }
}
//Threads mit TeilArrays erstellen
MyThread t1 = new MyThread(firstThirdOfTheArray);
MyThread t2 = new MyThread(secondThirdOfTheArray);
MyThread t3 = new MyThread(lastThirdOfTheArray);
//Threads starten
t1.start();
t2.start();
t3.start();
//darauf warten, dass sie beendet werden, die Reihenfolge der join() Befehle ist irrelevant, du wartest eh auf alle 3
t1.join();
t2.join();
t3.join();
System.out.println("done");