Java Academy · Pelajaran

Perangkap Lazim

Susunan, pembungkusan dan kumpulan umum

Pelajaran 4 daripada 413 langkah

Perangkap Lazim ialah pelajaran Java Academy percuma di CoddyKit. Ini ialah pelajaran 4 daripada 4. Anda boleh membaca keseluruhan pelajaran di bawah secara percuma — kemudian berlatih secara praktikal dalam pelayar menggunakan penyunting kod terbina dalam dan tutor kecerdasan buatan 24/7. Pelajaran ini merupakan sebahagian daripada laluan pembelajaran Java Academy, dan kemajuan anda disegerakkan merentas web serta aplikasi CoddyKit. Kursus Java Academy merangkumi sejumlah 4 pelajaran.

Keselarian Tidak Semestinya Lebih Laju

Menambah parallel() boleh menjadikan kod lebih perlahan, bukan lebih laju. Pelajaran ini menerangkan perangkap lazim supaya Anda boleh mengelakkannya.

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

Perangkap: Overhed Susunan

Operasi yang mengekalkan susunan seperti forEachOrdered atau limit memaksa penyelarasan merentas utas, sekali gus mengurangkan manfaat keselarian.

import java.util.stream.IntStream;

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

unordered Boleh Membantu

Jika susunan tidak penting, memanggil unordered() membolehkan masa jalan melangkau kerja penyusunan dan menjalankan pemprosesan selari dengan lebih bebas.

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

Perangkap: Pembungkusan Tersembunyi

Menggunakan Stream<Integer> secara selari menggandakan kos pembungkusan merentas utas. Utamakan strim primitif untuk kerja angka secara selari.

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

Perangkap: Kolam Sejagat yang Dikongsi

Semua strim selari berkongsi satu ForkJoinPool.commonPool(). Tugas selari yang panjang boleh menyebabkan tugas lain dalam JVM yang sama mengalami kebuluran, termasuk bahagian lain aplikasi Anda.

import java.util.concurrent.ForkJoinPool;

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

Mengasingkan Kerja dalam Kolam Tersuai

Untuk memastikan kerja berat tidak menggunakan kolam sejagat, serahkan strim selari dalam ForkJoinPool Anda sendiri.

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

Perangkap: Sumber yang Sukar Dibahagi

LinkedList, Stream.iterate dan BufferedReader.lines sukar dibahagikan. Menjalankannya secara selari sering memberikan sedikit manfaat atau malah mendatangkan kesan negatif.

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

Perangkap: Fungsi Lambda Berkeadaan

Fungsi lambda yang membaca atau menulis keadaan luaran berkelakuan tidak tentu secara selari. Pastikan fungsi lambda tanpa keadaan untuk mendapatkan hasil yang konsisten.

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

Perangkap: findFirst berbanding findAny

findFirst mesti menghormati susunan, lalu menambah overhed secara selari. Jika mana-mana elemen yang sepadan sudah memadai, gunakan findAny.

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

Perangkap: Operasi Murah pada Data Kecil

Untuk koleksi yang sangat kecil atau kerja yang remeh, overhed pembahagian dan penggabungan jauh melebihi sebarang manfaat. Kekalkan pelaksanaan berjujukan.

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

Perangkap: Cantuman Mahal dalam Pengumpul

Pengumpul dengan langkah cantuman yang mahal, seperti membina struktur tersusun yang besar, boleh menghapuskan manfaat keselarian. Pengumpulan mudah boleh digabungkan dengan murah.

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

Semakan Pantas

Mengapakah findFirst boleh menjadi lebih perlahan daripada findAny pada strim selari?

Jawab dalam pelajaran interaktif

Imbas Kembali

Anda telah mempelajari perangkap lazim pemprosesan selari:

Susunan (forEachOrdered, limit, findFirst) menambah kos penyelarasan; gunakan unordered atau findAny jika boleh.
Pembungkusan menggandakan kos; utamakan strim primitif.
Kolam sejagat yang dikongsi boleh menyebabkan kebuluran; asingkan kerja berat dalam ForkJoinPool tersuai.
Sumber yang sukar dibahagi, data kecil dan cantuman mahal semuanya menjejaskan keselarian.

Percuma untuk bermula

Pelajari Java dengan tutor kecerdasan buatan — percuma

Tulis dan jalankan kod sebenar dalam pelayar anda, dapatkan bantuan segera daripada tutor kecerdasan buatan yang tersedia 24/7, dan sambung semula dari tempat anda berhenti di web atau dalam aplikasi.

Kursus: 104
Pelajaran: 374

Mula belajar secara percuma Lihat kursus penuh

Soalan Lazim

Adakah pelajaran “Perangkap Lazim” percuma?

Ya — teks penuh “Perangkap Lazim” boleh dibaca secara percuma di web ini. Untuk berlatih secara interaktif menggunakan penyunting kod terbina dalam dan tutor kecerdasan buatan 24/7, serta membuka kunci baki kursus Java Academy, tingkat taraf kepada CoddyKit PRO. Kursus Java Academy merangkumi sejumlah 4 pelajaran.

Apakah yang akan saya pelajari dalam “Perangkap Lazim”?

Susunan, pembungkusan dan kumpulan umum Anda berlatih Java Academy menggunakan kod praktikal yang dijalankan terus dalam pelayar, manakala tutor kecerdasan buatan 24/7 menjawab soalan anda semasa anda mengikuti pelajaran.

Adakah saya memerlukan pengalaman untuk memulakan Java Academy?

Tiada pengalaman terdahulu diperlukan. Pembelajaran Java Academy di CoddyKit disusun untuk pelajar daripada peringkat pemula hingga lanjutan, jadi anda boleh bermula di sini atau dari awal dan belajar mengikut kadar anda sendiri. Ini ialah pelajaran 4 daripada 4.

Berapa lamakah pelajaran “Perangkap Lazim” diambil?

Kebanyakan pelajaran CoddyKit mengambil masa kira-kira 5–10 minit. Setiap pelajaran ringkas dan interaktif, jadi anda boleh membuat kemajuan secara berterusan dan menyambung tepat dari tempat anda berhenti di web atau aplikasi.

Bolehkah saya menulis dan menjalankan kod dalam pelajaran Java Academy ini?

Ya. Setiap pelajaran Java Academy menyertakan penyunting kod terbina dalam, jadi anda boleh menulis dan menjalankan kod sebenar terus dalam pelayar serta menerima maklum balas kecerdasan buatan serta-merta — tanpa memerlukan persediaan setempat.

Semua pelajaran dalam kursus ini

← Kembali ke Java Academy