Java Academy · Ders

Yaygın Tuzaklar

Sıralama, kutulama ve ortak havuz

Yaygın Tuzaklar, CoddyKit'te ücretsiz bir Java Academy dersidir. Bu, 4 dersinin 4. dersidir. Aşağıdan dersin tamamını ücretsiz okuyabilir, sonra tarayıcıda yerleşik kod editörü ve 7/24 yapay zeka koçu ile uygulamalı olarak pratik yapabilirsin. Bu, Java Academy öğrenme yolunun bir parçasıdır ve ilerlemeniz web ve CoddyKit uygulaması arasında senkronize olur. Java Academy kursu toplamda 4 dersten oluşur.

parallel Bedava Hız Değildir

parallel() eklemek, kodu hızlandırmak yerine yavaşlatabilir. Bu derste, bunlardan kaçınabilmeniz için yaygın tuzaklar ele alınmaktadır.

import java.util.stream.IntStream;

public class Main {
    public static void main(String[] args) {
        long sum = IntStream.rangeClosed(1, 1_000_000).parallel()
            .asLongStream().sum();
        System.out.println(sum);
    }
}

Tuzak: Sıralama Ek Yükü

forEachOrdered veya limit gibi sıralı işlemler, iş parçacıkları arasında eşgüdüm gerektirerek paralellik kazanımlarını azaltır.

import java.util.stream.IntStream;

public class Main {
    public static void main(String[] args) {
        IntStream.rangeClosed(1, 5).parallel()
            .forEachOrdered(System.out::println);
    }
}

unordered Yardımcı Olabilir

Sıra önemli değilse unordered() çağrısı, çalışma ortamının sıralama işini atlamasına ve daha serbest biçimde paralelleştirme yapmasına olanak tanır.

import java.util.stream.IntStream;

public class Main {
    public static void main(String[] args) {
        long count = IntStream.rangeClosed(1, 1_000_000).parallel()
            .unordered()
            .filter(n -> n % 5 == 0)
            .count();
        System.out.println(count);
    }
}

Tuzak: Gizli Kutulama

Paralel çalışmada Stream<Integer> kullanmak, kutulama maliyetini iş parçacıkları arasında katlar. Sayısal paralel işler için ilkel tür akışlarını tercih edin.

import java.util.stream.IntStream;

public class Main {
    public static void main(String[] args) {
        long sum = IntStream.rangeClosed(1, 1_000_000).parallel().asLongStream().sum();
        System.out.println(sum);
    }
}

Tuzak: Paylaşılan Ortak Havuz

Tüm paralel stream'ler tek bir ForkJoinPool.commonPool() havuzunu paylaşır. Uzun süren bir paralel görev, aynı JVM içindeki diğer görevleri ve uygulamanızın diğer bölümlerini kaynak bekler hâle getirebilir.

import java.util.concurrent.ForkJoinPool;

public class Main {
    public static void main(String[] args) {
        System.out.println(ForkJoinPool.commonPool().getParallelism());
    }
}

Çalışmayı Özel Bir Havuzda Yalıtma

Ağır işlerin ortak havuzda çalışmasını önlemek için paralel stream'i kendi ForkJoinPool havuzunuzun içinde gönderin.

import java.util.concurrent.ForkJoinPool;
import java.util.stream.IntStream;

public class Main {
    public static void main(String[] args) throws Exception {
        ForkJoinPool pool = new ForkJoinPool(2);
        long sum = pool.submit(() ->
            IntStream.rangeClosed(1, 1_000_000).parallel().asLongStream().sum()
        ).get();
        pool.shutdown();
        System.out.println(sum);
    }
}

Tuzak: Kötü Bölünebilen Kaynaklar

LinkedList, Stream.iterate ve BufferedReader.lines kötü bölünür. Bunları paralelleştirmek çoğu zaman çok az yarar sağlar veya olumsuz sonuç verir.

import java.util.stream.Stream;

public class Main {
    public static void main(String[] args) {
        long n = Stream.iterate(1, x -> x + 1)
            .limit(100_000)
            .parallel()
            .filter(x -> x % 2 == 0)
            .count();
        System.out.println(n);
    }
}

Tuzak: Durum Taşıyan Lambda İfadeleri

Dış durumu okuyan veya yazan lambda ifadeleri, paralel çalışmada belirlenimsiz davranır. Tutarlı sonuçlar elde etmek için bunları durumsuz tutun.

import java.util.stream.IntStream;

public class Main {
    public static void main(String[] args) {
        int sum = IntStream.rangeClosed(1, 100).parallel()
            .map(n -> n + 1)
            .sum();
        System.out.println(sum);
    }
}

Tuzak: findFirst ve findAny

findFirst sıraya uymak zorundadır; bu da paralel çalışmada ek yük oluşturur. Eşleşen herhangi bir öğe yeterliyse findAny kullanın.

import java.util.stream.IntStream;

public class Main {
    public static void main(String[] args) {
        int found = IntStream.rangeClosed(1, 1_000_000).parallel()
            .filter(n -> n % 99991 == 0)
            .findAny()
            .getAsInt();
        System.out.println(found);
    }
}

Tuzak: Küçük Verilerde Ucuz İşlemler

Çok küçük koleksiyonlarda veya önemsiz işlerde bölme ve birleştirme ek yükü, tüm kazanımları aşar. Sıralı çalışmayı tercih edin.

import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<Integer> small = List.of(1, 2, 3, 4);
        int sum = small.stream().mapToInt(Integer::intValue).sum();
        System.out.println(sum);
    }
}

Tuzak: Toplayıcılarda Pahalı Birleştirme

Büyük sıralı yapılar oluşturmak gibi pahalı birleştirme adımlarına sahip toplayıcılar, paralellik kazanımlarını ortadan kaldırabilir. Basit biriktirmeler ucuza birleştirilir.

import java.util.stream.IntStream;

public class Main {
    public static void main(String[] args) {
        long total = IntStream.rangeClosed(1, 1_000_000).parallel()
            .mapToLong(n -> n)
            .sum();
        System.out.println(total);
    }
}

Hızlı Kontrol

Paralel bir stream'de findFirst neden findAny'den daha yavaş olabilir?

Özet

Yaygın paralellik tuzaklarını öğrendiniz:

Sıralama (forEachOrdered, limit, findFirst) eşgüdüm maliyeti ekler; mümkün olduğunda unordered veya findAny kullanın.
Kutulama maliyeti katlar; ilkel tür akışlarını tercih edin.
Paylaşılan ortak havuz kaynak bekleyebilir; ağır işleri özel bir ForkJoinPool havuzunda yalıtın.
Kötü bölünebilen kaynaklar, küçük veriler ve pahalı birleştirmelerin tümü paralelliği zayıflatır.

Sıkça Sorulan Sorular

“Yaygın Tuzaklar” dersi ücretsiz mi?

Evet — “Yaygın Tuzaklar” dersin tüm metni burada web'de ücretsiz olarak okunabilir. Etkileşimli olarak pratik yapmak (yerleşik kod editörü ve 7/24 yapay zeka koçu) ve Java Academy kursunun geri kalanını açmak için CoddyKit PRO'ya yükselt. Java Academy kursu toplamda 4 dersten oluşur.

“Yaygın Tuzaklar” dersinde ne öğreneceğim?

Sıralama, kutulama ve ortak havuz Java Academy ile uygulamalı kodu tarayıcıda doğrudan çalıştırarak pratik yaparsın ve 7/24 yapay zeka koçu dersi çalışırken sorularını yanıtlar.

Java Academy öğrenmeye başlamak için deneyim gerekli mi?

Önceden deneyim gerekmez. CoddyKit'te Java Academy, başlangıçtan ileri seviyeye kadar yapılandırıldığı için buradan başlayabilir veya başından başlayıp kendi hızında ilerleme yapabilirsin. Bu, 4 dersinin 4. dersidir.

“Yaygın Tuzaklar” dersi ne kadar sürer?

Çoğu CoddyKit dersi yaklaşık 5–10 dakika sürer. Her biri kısa ve etkileşimli olduğu için sabit ilerleme yaparsın ve web ile uygulama arasında tam olarak bıraktığın yerden devam edebilirsin.

Bu Java Academy dersinde kod yazıp çalıştırabilir miyim?

Evet. Her Java Academy dersi yerleşik bir kod editörü içerir, bu sayede tarayıcıda gerçek kod yazıp çalıştırabilir ve anlık yapay zeka geri bildirimi alırsın — yerel kurulum gerekli değildir.

Bu kursun tüm dersleri

← Java Academy Sayfasına Dön