Por que dois threads Java (em alguns casos) mais de duas vezes mais rápido que um?

Question

arquivo: 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);


    }

}

arquivo: 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;
        }        
    }
}

Quando eu executo isso, Ele produz:

Executar tempo para um segmento: 1219

tempo de execução para dois tópicos: 281

ou algo muito próximo.

Por que existe essa diferença? Por que dividindo-o em dois tópicos ir mais de duas vezes mais rápido do que apenas executá-lo diretamente?

Answer 1

Você está realmente não espera para os fios ao fim em tudo.

Uma vez que você iniciar uma discussão, então você deve chamar .join () sobre ele para esperar por ele para ser concluído. O que está acontecendo aqui é que todos os seus tópicos estão começando e logo que o último foi iniciado, você relógio-lo e, em seguida, calcular o tempo de paragem. Isso significa que seus tópicos ainda estão em execução em segundo plano.

Edit:. A razão pela qual a primeira leva tanto tempo é porque você está fazendo uma série de chamadas síncronas, enquanto a criação de um fio e iniciá-lo gera uma tarefa assíncrona

Edit 2: Aqui está um diagrama de sequência guardanapo do que acontece em seu primeiro teste: http://www.websequencediagrams.com/cgi-bin / cdraw? lz = TWFpbi0-RXhhbXBsZTE6IFRhc2sgc3RhcnRlZAphY3RpdmF0ZSAAGAgKACEILS0-TWFpbjogZG9uZQpkZQAYEgABWAABWAABgTFlMQo & s = guardanapo

Aqui está um diagrama de sequência guardanapo do que acontece em seu segundo teste: http://www.websequencediagrams.com/cgi-bin/cdraw?lz = TWFpbi0tPkFub255bW91cyBUaHJlYWQ6IFN0YXJ0IEV4YW1wbGUxLnRhc2soKQoACSYyAAEuAAFdAAGBOwCCPjoAgyIGPk1haW46ICJIb3cgbG9uZyBkaWQgdGhhdCB0YWtlPyIKAINmEC0AKwhUYXNrcyBiZWdpbiB0byBmaW5pc2guLi4gKHNvbWUgbWF5IGhhdmUgZW5kZWQgZWFybGllcikK & s = guardanapo

3 Editar: Eu apenas percebido que o segundo diagrama de sequência de todos os pontos das setas à mesma / fio /. Eles estão em linhas diferentes verdade, cada chamada.

Answer 2

O início da chamada () em um segmento retorna imediatamente porque só enfileira o segmento. O fio em si começará a ser executado em segundo plano algum tempo mais tarde.

Answer 3

Aqui está o que eu recebo com o seu código adicionando juntar-se aos tópicos:

Executar tempo para um segmento: 566

tempo de execução para dois tópicos: 294

Assim respostas anteriores estão corretas.

EDIT: Eu adicionei junta-se desta forma. Você pode fazê-lo melhor, mas não importa:

    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();
        }
    }

Você tem que se juntar cada segmento. No entanto, você não desperdice o seu tempo de espera na join (), porque outros segmentos não estão bloqueadas. Se a discussão terminou de executution antes de chamar para participar, você simplesmente continuar para a próxima linha.

Além disso, o que faz o seu último comentário média?