Java 8: prestazioni di stream vs collezioni

Sono nuovo di Java 8. Non conosco ancora in modo approfondito l'API, ma ho fatto un piccolo benchmark informale per confrontare le prestazioni della nuova API Streams rispetto alle vecchie vecchie Collezioni.

Il test consiste nel filtrare un elenco di Integer, e per ogni numero pari, calcolare la radice quadrata e memorizzarla in un risultato Listdi Double.

Ecco il codice:

    public static void main(String[] args) {
        //Calculating square root of even numbers from 1 to N       
        int min = 1;
        int max = 1000000;

        List<Integer> sourceList = new ArrayList<>();
        for (int i = min; i < max; i++) {
            sourceList.add(i);
        }

        List<Double> result = new LinkedList<>();


        //Collections approach
        long t0 = System.nanoTime();
        long elapsed = 0;
        for (Integer i : sourceList) {
            if(i % 2 == 0){
                result.add(Math.sqrt(i));
            }
        }
        elapsed = System.nanoTime() - t0;       
        System.out.printf("Collections: Elapsed time:\t %d ns \t(%f seconds)%n", elapsed, elapsed / Math.pow(10, 9));


        //Stream approach
        Stream<Integer> stream = sourceList.stream();       
        t0 = System.nanoTime();
        result = stream.filter(i -> i%2 == 0).map(i -> Math.sqrt(i)).collect(Collectors.toList());
        elapsed = System.nanoTime() - t0;       
        System.out.printf("Streams: Elapsed time:\t\t %d ns \t(%f seconds)%n", elapsed, elapsed / Math.pow(10, 9));


        //Parallel stream approach
        stream = sourceList.stream().parallel();        
        t0 = System.nanoTime();
        result = stream.filter(i -> i%2 == 0).map(i -> Math.sqrt(i)).collect(Collectors.toList());
        elapsed = System.nanoTime() - t0;       
        System.out.printf("Parallel streams: Elapsed time:\t %d ns \t(%f seconds)%n", elapsed, elapsed / Math.pow(10, 9));      
    }.

E qui ci sono i risultati per una macchina dual core:

    Collections: Elapsed time:        94338247 ns   (0,094338 seconds)
    Streams: Elapsed time:           201112924 ns   (0,201113 seconds)
    Parallel streams: Elapsed time:  357243629 ns   (0,357244 seconds)

Per questo particolare test, i flussi sono circa due volte più lenti delle raccolte e il parallelismo non aiuta (o o lo sto usando nel modo sbagliato?).

Domande:

• Questo test è giusto? Ho fatto qualche errore?
• I flussi sono più lenti delle raccolte? Qualcuno ha fatto un buon punto di riferimento formale su questo?
• Quale approccio dovrei lottare?

Risultati aggiornati.

Ho eseguito il test 1k volte dopo il riscaldamento JVM (iterazioni 1k) come consigliato da @pveentjer:

    Collections: Average time:      206884437,000000 ns     (0,206884 seconds)
    Streams: Average time:           98366725,000000 ns     (0,098367 seconds)
    Parallel streams: Average time: 167703705,000000 ns     (0,167704 seconds)

In questo caso i flussi sono più performanti. Mi chiedo cosa verrebbe osservato in un'app in cui la funzione di filtro viene chiamata solo una o due volte durante il runtime.

1. Smetti di usarlo LinkedListper tutto tranne che per rimuoverlo pesantemente dalla metà dell'elenco usando iteratore.

2. Smetti di scrivere a mano il codice di benchmarking, usa JMH .

Parametri corretti:

@OutputTimeUnit(TimeUnit.NANOSECONDS)
@BenchmarkMode(Mode.AverageTime)
@OperationsPerInvocation(StreamVsVanilla.N)
public class StreamVsVanilla {
    public static final int N = 10000;

    static List<Integer> sourceList = new ArrayList<>();
    static {
        for (int i = 0; i < N; i++) {
            sourceList.add(i);
        }
    }

    @Benchmark
    public List<Double> vanilla() {
        List<Double> result = new ArrayList<>(sourceList.size() / 2 + 1);
        for (Integer i : sourceList) {
            if (i % 2 == 0){
                result.add(Math.sqrt(i));
            }
        }
        return result;
    }

    @Benchmark
    public List<Double> stream() {
        return sourceList.stream()
                .filter(i -> i % 2 == 0)
                .map(Math::sqrt)
                .collect(Collectors.toCollection(
                    () -> new ArrayList<>(sourceList.size() / 2 + 1)));
    }
}

Risultato:

Benchmark                   Mode   Samples         Mean   Mean error    Units
StreamVsVanilla.stream      avgt        10       17.588        0.230    ns/op
StreamVsVanilla.vanilla     avgt        10       10.796        0.063    ns/op

Proprio come mi aspettavo l'implementazione del flusso è abbastanza più lenta. JIT è in grado di incorporare tutte le cose lambda ma non produce un codice perfettamente conciso come la versione vaniglia.

Generalmente, i flussi Java 8 non sono magici. Non sono stati in grado di velocizzare cose già ben implementate (con, probabilmente, semplici iterazioni o istruzioni for-Java Java 5 sostituite con Iterable.forEach()e Collection.removeIf()chiamate). Gli stream riguardano più la convenienza e la sicurezza della codifica. Convenienza - il trade-off di velocità sta funzionando qui.

1) Vedi il tempo meno di 1 secondo usando il tuo benchmark. Ciò significa che può esserci una forte influenza degli effetti collaterali sui risultati. Quindi, ho aumentato il tuo compito 10 volte

    int max = 10_000_000;

e ha eseguito il tuo benchmark. I miei risultati:

Collections: Elapsed time:   8592999350 ns  (8.592999 seconds)
Streams: Elapsed time:       2068208058 ns  (2.068208 seconds)
Parallel streams: Elapsed time:  7186967071 ns  (7.186967 seconds)

senza i int max = 1_000_000risultati di edit ( ) erano

Collections: Elapsed time:   113373057 ns   (0.113373 seconds)
Streams: Elapsed time:       135570440 ns   (0.135570 seconds)
Parallel streams: Elapsed time:  104091980 ns   (0.104092 seconds)

È come i tuoi risultati: il flusso è più lento della raccolta. Conclusione: molto tempo è stato impiegato per l'inizializzazione del flusso / la trasmissione dei valori.

2) Dopo aver aumentato il flusso di attività è diventato più veloce (va bene), ma il flusso parallelo è rimasto troppo lento. Cosa c'è che non va? Nota: hai collect(Collectors.toList())nel tuo comando. La raccolta in un'unica raccolta introduce essenzialmente colli di bottiglia delle prestazioni e spese generali in caso di esecuzione simultanea. È possibile stimare il costo relativo delle spese generali sostituendolo

collecting to collection -> counting the element count

Per i flussi può essere fatto da collect(Collectors.counting()). Ho ottenuto risultati:

Collections: Elapsed time:   41856183 ns    (0.041856 seconds)
Streams: Elapsed time:       546590322 ns   (0.546590 seconds)
Parallel streams: Elapsed time:  1540051478 ns  (1.540051 seconds)

Questo è per un grande compito! ( int max = 10000000) Conclusione: la raccolta degli articoli da collezionare ha richiesto la maggior parte del tempo. La parte più lenta viene aggiunta all'elenco. A proposito, semplice ArrayListè usato per Collectors.toList().

    public static void main(String[] args) {
    //Calculating square root of even numbers from 1 to N       
    int min = 1;
    int max = 10000000;

    List<Integer> sourceList = new ArrayList<>();
    for (int i = min; i < max; i++) {
        sourceList.add(i);
    }

    List<Double> result = new LinkedList<>();


    //Collections approach
    long t0 = System.nanoTime();
    long elapsed = 0;
    for (Integer i : sourceList) {
        if(i % 2 == 0){
            result.add( doSomeCalculate(i));
        }
    }
    elapsed = System.nanoTime() - t0;       
    System.out.printf("Collections: Elapsed time:\t %d ns \t(%f seconds)%n", elapsed, elapsed / Math.pow(10, 9));


    //Stream approach
    Stream<Integer> stream = sourceList.stream();       
    t0 = System.nanoTime();
    result = stream.filter(i -> i%2 == 0).map(i -> doSomeCalculate(i))
            .collect(Collectors.toList());
    elapsed = System.nanoTime() - t0;       
    System.out.printf("Streams: Elapsed time:\t\t %d ns \t(%f seconds)%n", elapsed, elapsed / Math.pow(10, 9));


    //Parallel stream approach
    stream = sourceList.stream().parallel();        
    t0 = System.nanoTime();
    result = stream.filter(i -> i%2 == 0).map(i ->  doSomeCalculate(i))
            .collect(Collectors.toList());
    elapsed = System.nanoTime() - t0;       
    System.out.printf("Parallel streams: Elapsed time:\t %d ns \t(%f seconds)%n", elapsed, elapsed / Math.pow(10, 9));      
}

static double doSomeCalculate(int input) {
    for(int i=0; i<100000; i++){
        Math.sqrt(i+input);
    }
    return Math.sqrt(input);
}

Cambio un po 'il codice, ho eseguito sul mio mac book pro che ha 8 core, ho ottenuto un risultato ragionevole:

Collezioni: tempo trascorso: 1522036826 ns (1,522037 secondi)

Flussi: tempo trascorso: 4315833719 ns (4.315834 secondi)

Flussi paralleli: tempo trascorso: 261152901 ns (0,261153 secondi)

Per quello che stai cercando di fare, non userei comunque i normali java api. C'è un sacco di boxe / unboxing in corso, quindi c'è un enorme sovraccarico di prestazioni.

Personalmente penso che molte API progettate siano una schifezza perché creano molta lettiera.

Prova a usare una matrice primitiva di double / int e prova a farlo a thread singolo e guarda qual è la performance.

PS: potresti dare un'occhiata a JMH per occuparti del benchmark. Si occupa di alcune delle insidie ​​tipiche come il riscaldamento della JVM.