Warum sind zwei Java-Threads (in einigen Fällen) mehr als doppelt so schnell wie ein?

Question

Datei: Example1.java

public class Example1 implements Runnable {

    public void run() {
        for(int i = 0; i < 100000000; i++) {
            int x = 5;
            x = x * 4;
            x = x % 3;
            x = x + 9000;
            x = x * 923;
        }
    }

    public static void task() {
        for(int i = 0; i < 100000000; i++) {
            int x = 5;
            x = x * 4;
            x = x % 3;
            x = x + 9000;
            x = x * 923;
        }
        for(int i = 0; i < 100000000; i++) {
            int x = 9;
            x = x * 2;
            x = x % 4;
            x = x + 3241;
            x = x * 472;
        }
    }

    public static void main(String[] args) {

        long startTime = System.currentTimeMillis();
            Example1.task();
            Example1.task();
            Example1.task();
            Example1.task();
            Example1.task();
        long stopTime = System.currentTimeMillis();
        long runTime = stopTime - startTime;
        System.out.println("Run time for one thread: " + runTime);


        startTime = System.Example1();
            (new Thread(new Example1())).start();
            (new Thread(new Example2())).start();
            (new Thread(new Example1())).start();
            (new Thread(new Example2())).start();
            (new Thread(new Example1())).start();
            (new Thread(new Example2())).start();
            (new Thread(new Example1())).start();
            (new Thread(new Example2())).start();
            (new Thread(new Example1())).start();
            (new Thread(new Example2())).start();
        stopTime = System.currentTimeMillis();
        runTime = stopTime - startTime;
        System.out.println("Run time for two threads: " + runTime);


    }

}

Datei: Example2.java

public class Example2 implements Runnable {

    public void run() {
        for(int i = 0; i < 100000000; i++) {
            int x = 9;
            x = x * 2;
            x = x % 4;
            x = x + 3241;
            x = x * 472;
        }        
    }
}

Als ich das laufen, gibt sie:

  

Laufzeit für einen Thread: 1219

     

Laufzeit für zwei Threads: 281

oder etwas ganz in der Nähe.

Warum gibt es solch ein Unterschied? Warum Aufspaltung in zwei Fäden gehen mehr als zwei Mal schneller als nur direkt ausgeführt werden?

Answer 1

Sie warten eigentlich nicht für die Fäden überhaupt zu beenden.

Wenn Sie einen Thread starten, müssen Sie rufen Sie dann .join () auf sie zu warten, bis es zu vervollständigen. Was hier passiert, ist, dass alle Threads beginnen und sobald der letzte begonnen hat, ist es Ihnen Uhr und dann die Stoppzeit zu berechnen. Dies bedeutet, dass Ihre Threads laufen im Hintergrund weiter.

Edit:. Der Grund, warum die erste so lange dauert, weil Sie eine Reihe von synchronen Anrufen machen, während einen Thread erstellen und startete es eine asynchrone Aufgabe laicht

Edit 2: Hier ist eine Serviette Sequenzdiagramm von dem, was in Ihrem ersten Test passiert: http://www.websequencediagrams.com/cgi-bin / cdraw? lz = TWFpbi0-RXhhbXBsZTE6IFRhc2sgc3RhcnRlZAphY3RpdmF0ZSAAGAgKACEILS0-TWFpbjogZG9uZQpkZQAYEgABWAABWAABgTFlMQo & s = Serviette

Hier ist eine Serviette Sequenzdiagramm von dem, was in Ihrem zweiten Test passiert: http://www.websequencediagrams.com/cgi-bin/cdraw?lz = TWFpbi0tPkFub255bW91cyBUaHJlYWQ6IFN0YXJ0IEV4YW1wbGUxLnRhc2soKQoACSYyAAEuAAFdAAGBOwCCPjoAgyIGPk1haW46ICJIb3cgbG9uZyBkaWQgdGhhdCB0YWtlPyIKAINmEC0AKwhUYXNrcyBiZWdpbiB0byBmaW5pc2guLi4gKHNvbWUgbWF5IGhhdmUgZW5kZWQgZWFybGllcikK & s = Serviette

Edit 3: Ich habe erkannt, dass die zweite Sequenzdiagramm Punkte alle der Pfeile an den / same / Thread. Sie sind in der Tat verschiedene Threads, jeder Anruf.

Answer 2

Der Aufruf start () auf einem Thema sofort zurück, weil es nur den Faden einreiht. Der Faden selbst beginnt im Hintergrund laufen einige Zeit später.

Answer 3

Hier ist, was ich mit dem Code zu den Themen verbinden und fügt hinzu:

  

Laufzeit für einen Thread: 566

     

Laufzeit für zwei Threads: 294

So bisherige Antworten sind richtig.

EDIT: Ich habe diese Art und Weise verbindet. Sie können es besser machen, aber es spielt keine Rolle:

    Thread[] t = new Thread[10];
    (t[0] = new Thread(new Example1())).start();
    (t[1] = new Thread(new Example2())).start();
    (t[2] = new Thread(new Example1())).start();
    (t[3] = new Thread(new Example2())).start();
    (t[4] = new Thread(new Example1())).start();
    (t[5] = new Thread(new Example2())).start();
    (t[6] = new Thread(new Example1())).start();
    (t[7] = new Thread(new Example2())).start();
    (t[8] = new Thread(new Example1())).start();
    (t[9] = new Thread(new Example2())).start();

    for (Thread t1: t) {
        try {
            t1.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

Sie müssen jeden Thread verbinden. Allerdings müssen Sie Ihre Zeit nicht mitmachen warten (), weil andere Threads nicht blockiert sind. Wenn der Thread beendet hat es executution bevor Sie beitreten nennen, die Sie gerade zum nächsten Thread fortgesetzt werden.

Auch, was ist Ihre letzte Bemerkung bedeuten?