Java 8: Akışların Koleksiyonlara Karşı Performansı

Java 8'de yeniyim. Hala API'yi derinlemesine bilmiyorum, ancak yeni Streams API'nin performansını eski iyi Koleksiyonlarla karşılaştırmak için küçük bir gayri resmi karşılaştırma yaptım.

Test, bir listeyi filtrelemek Integerve her çift sayı için kare kökü hesaplamak ve bunun bir sonucu Listolarak saklamaktan oluşur Double.

İşte kod:

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

Ve çift çekirdekli bir makinenin sonuçları:

    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)

Bu özel test için, akışlar koleksiyonların yaklaşık iki katı kadar yavaştır ve paralellik yardımcı olmaz (ya da yanlış şekilde mi kullanıyorum?).

Sorular:

• Bu test adil mi? Herhangi bir hata yaptım mı?
• Akışlar koleksiyonlardan daha mı yavaş? Bu konuda iyi bir resmi kıyaslama yapan var mı?
• Hangi yaklaşım için çabalamalıyım?

Güncelleme sonuçları.

JVM ısınmasından (1k iterasyon) sonra @pveentjer tarafından tavsiye edildiği gibi testi 1k kez çalıştırdım:

    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)

Bu durumda akışlar daha performanslıdır. Filtreleme işlevinin çalışma sırasında yalnızca bir veya iki kez çağrıldığı bir uygulamada ne gözlemleneceğini merak ediyorum.

1. LinkedListYineleyici kullanarak listenin ortasından ağır kaldırma dışında herhangi bir şey için kullanmayı bırakın .

2. Kıyaslama kodunu elle yazmayı bırakın, JMH kullanın .

Uygun kriterler:

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

Sonuç:

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

Beklediğim gibi, akış uygulaması oldukça yavaştır. JIT tüm lambda malzemelerini satır içine alabilir ancak vanilya sürümü kadar mükemmel özlü kod üretmez.

Genellikle, Java 8 akışları sihir değildir. Zaten iyi uygulanmış şeyleri hızlandıramazlardı (muhtemelen, düz yinelemeler veya her bir ifade için değiştirilen Iterable.forEach()ve çağrılan Java 5'ler Collection.removeIf()). Akışlar daha çok kodlama kolaylığı ve güvenliği ile ilgilidir. Kolaylık - hız dengesi burada çalışıyor.

1) Ölçüt kullanarak 1 saniyeden daha kısa bir süre görürsünüz. Bu, yan etkilerin sonuçlarınız üzerinde güçlü bir etkisi olabileceği anlamına gelir. Bu yüzden görevini 10 kat arttırdım

    int max = 10_000_000;

ve kıyas ölçütünüzü yönetti. Benim sonuçlarım:

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)

edit ( int max = 1_000_000) sonuçları olmadan

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)

Sonuçlarınız gibi: akış koleksiyondan daha yavaş. Sonuç: Akım başlatma / iletme değerleri için çok zaman harcandı.

2) Artan görev akışı daha hızlı hale geldi (sorun değil), ancak paralel akış çok yavaş kaldı. Sorun nedir? Not: collect(Collectors.toList())Komutunuz var. Tek bir koleksiyona toplamak, esasen eşzamanlı yürütme durumunda performans darboğazını ve ek yükü getirir. Değiştirerek genel masrafların göreceli maliyetini tahmin etmek mümkündür

collecting to collection -> counting the element count

Akarsu için tarafından yapılabilir collect(Collectors.counting()). Sonuçları aldım:

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)

Bu büyük bir görev için! ( int max = 10000000) Sonuç: koleksiyona eşya toplamak çok zaman aldı. En yavaş kısım listeye eklenmesidir. BTW, basit ArrayListiçin kullanılır 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);
}

Kodu biraz değiştirdim, 8 çekirdeği olan mac kitap pro'mda koştum, makul bir sonuç aldım:

Koleksiyonlar: Geçen süre: 1522036826 ns (1.522037 saniye)

Akışlar: Geçen süre: 4315833719 ns (4.315834 saniye)

Paralel akışlar: Geçen süre: 261152901 ns (0.261153 saniye)

Yapmaya çalıştığın şey için, normal java api'leri zaten kullanmam. Bir ton boks / kutulama var, bu yüzden büyük bir performans yükü var.

Şahsen ben tasarlanmış bir çok API bok çünkü onlar bir sürü nesne çöp oluşturmak düşünüyorum.

Çift / int ilkel dizilerini kullanmaya çalışın ve bunu tek iş parçacıklı yapmaya ve performansın ne olduğunu görün.

Not: Benchmark yapmak için JMH'ye bakmak isteyebilirsiniz. JVM'yi ısıtmak gibi bazı tipik tuzaklarla ilgilenir.