Kapan Paralelisme Membantu
Faktor beban kerja dan ukuran data.
Kapan Paralelisme Membantu adalah pelajaran Java Academy gratis di CoddyKit. Ini adalah pelajaran 2 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar Java Academy, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus Java Academy mencakup 4 pelajaran total.
Paralelisme Memiliki Biaya
Beralih ke parallel menambah beban tambahan: membagi data, mengirimkan tugas, dan menggabungkan hasil. Penggunaan parallel hanya menguntungkan jika biaya tersebut lebih kecil daripada waktu yang dihemat.
import java.util.stream.IntStream;
public class Main {
public static void main(String[] args) {
long sum = IntStream.rangeClosed(1, 10_000_000)
.parallel()
.asLongStream()
.sum();
System.out.println(sum);
}
}Faktor 1: Ukuran Data (N)
N yang besar membuat biaya tetap paralelisme menjadi relatif kecil. Sebagai perkiraan kasar, diperlukan puluhan ribu elemen sebelum parallel mulai layak digunakan.
import java.util.stream.IntStream;
public class Main {
public static void main(String[] args) {
long count = IntStream.rangeClosed(1, 5_000_000)
.parallel()
.filter(n -> n % 7 == 0)
.count();
System.out.println(count);
}
}Faktor 2: Pekerjaan per Elemen (Q)
Biaya Q untuk memproses setiap elemen juga penting. Pekerjaan berat untuk setiap elemen mendapat manfaat dari paralelisme, bahkan pada N yang lebih kecil.
import java.util.stream.IntStream;
public class Main {
public static void main(String[] args) {
long primes = IntStream.rangeClosed(2, 200_000)
.parallel()
.filter(Main::isPrime)
.count();
System.out.println(primes);
}
static boolean isPrime(int n) {
for (int i = 2; (long) i * i <= n; i++)
if (n % i == 0) return false;
return true;
}
}Intuisi N dikali Q
Bayangkan total pekerjaan yang bermanfaat sebagai N x Q. Semakin besar hasil perkalian tersebut, semakin besar manfaat paralelisme. N yang sangat kecil atau Q yang sepele jarang membenarkan penggunaannya.
import java.util.stream.IntStream;
public class Main {
public static void main(String[] args) {
double sum = IntStream.rangeClosed(1, 1_000_000)
.parallel()
.mapToDouble(n -> Math.sqrt(n) * Math.log(n + 1))
.sum();
System.out.println(sum);
}
}Faktor 3: Kemampuan untuk Dibagi
Sumber data yang dapat dibagi dengan murah dan merata dapat diparalelkan dengan baik: larik, ArrayList, dan IntStream.range. LinkedList dan sumber berbasis iterator sulit dibagi.
import java.util.ArrayList;
import java.util.List;
public class Main {
public static void main(String[] args) {
List<Integer> list = new ArrayList<>();
for (int i = 0; i < 1_000_000; i++) list.add(i);
long even = list.parallelStream().filter(n -> n % 2 == 0).count();
System.out.println(even);
}
}Sumber yang Baik: Larik dan Rentang
Rentang primitif memiliki ukuran yang diketahui dan dapat dibagi dalam O(1), sehingga ideal sebagai sumber parallel.
import java.util.stream.LongStream;
public class Main {
public static void main(String[] args) {
long sum = LongStream.rangeClosed(1, 20_000_000)
.parallel()
.sum();
System.out.println(sum);
}
}Sumber yang Buruk: Pembangkit Iteratif
Stream.iterate menghasilkan elemen secara berurutan menurut definisinya, sehingga tidak dapat dibagi sampai elemen-elemen tersebut diwujudkan. Ini merupakan sumber parallel yang lemah.
import java.util.stream.Stream;
public class Main {
public static void main(String[] args) {
long count = Stream.iterate(1, n -> n + 1)
.limit(1_000_000)
.parallel()
.filter(n -> n % 2 == 0)
.count();
System.out.println(count);
}
}Faktor 4: Langkah Penggabungan yang Murah
Paralelisme memerlukan cara yang murah untuk menggabungkan hasil parsial. sum dan count dapat digabungkan dengan mudah; membangun daftar terurut atau menggunakan kolektor yang banyak memakai struktur pohon memerlukan penggabungan yang mahal.
import java.util.stream.IntStream;
public class Main {
public static void main(String[] args) {
int max = IntStream.rangeClosed(1, 5_000_000)
.parallel()
.map(n -> n % 1000)
.max()
.getAsInt();
System.out.println(max);
}
}Hindari untuk Pekerjaan yang Terikat Masukan/Keluaran
Aliran parallel ditujukan untuk tugas yang terikat CPU pada kumpulan percabangan-penggabungan. Operasi masukan/keluaran yang memblokir menghabiskan sumber daya kumpulan bersama dan merugikan seluruh aplikasi. Sebagai gantinya, gunakan eksekutor khusus untuk operasi masukan/keluaran.
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 -> (long) n * n)
.sum();
System.out.println(total);
}
}Ukur, Jangan Menebak
Satu-satunya cara yang dapat diandalkan untuk mengetahui apakah parallel membantu adalah melakukan uji kinerja dengan data yang realistis. Intuisi tentang kinerja sering kali keliru.
import java.util.stream.LongStream;
public class Main {
public static void main(String[] args) {
long start = System.nanoTime();
long sum = LongStream.rangeClosed(1, 50_000_000).parallel().sum();
long ms = (System.nanoTime() - start) / 1_000_000;
System.out.println("sum=" + sum + " took ~" + ms + "ms");
}
}Daftar Periksa Praktis
Utamakan parallel jika semua kondisi berikut terpenuhi:
- N besar dan/atau pekerjaan per elemen mahal.
- Sumber yang dapat dibagi (larik, ArrayList, rentang).
- Penggabungan yang murah dan asosiatif.
- Terikat CPU, tanpa operasi masukan/keluaran yang memblokir.
import java.util.stream.IntStream;
public class Main {
public static void main(String[] args) {
double avg = IntStream.rangeClosed(1, 10_000_000)
.parallel()
.mapToDouble(Math::sqrt)
.average()
.getAsDouble();
System.out.println(avg);
}
}Pemeriksaan Singkat
Skenario mana yang paling cocok untuk aliran parallel?
Rangkuman
Anda telah mempelajari kapan paralelisme membantu:
- Manfaatnya meningkat seiring N x Q (ukuran data dikali biaya per elemen).
- Diperlukan sumber yang dapat dibagi (larik, ArrayList, rentang).
- Diperlukan penggabungan yang murah dan asosiatif.
- Jaga agar pekerjaan tetap terikat CPU, hindari operasi masukan/keluaran yang memblokir, dan selalu lakukan pengukuran.
Pertanyaan yang Sering Diajukan
Apakah pelajaran “Kapan Paralelisme Membantu” gratis?
Ya — teks lengkap “Kapan Paralelisme Membantu” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus Java Academy, upgrade ke CoddyKit PRO. Kursus Java Academy mencakup 4 pelajaran total.
Apa yang akan aku pelajari di “Kapan Paralelisme Membantu”?
Faktor beban kerja dan ukuran data. Kamu berlatih Java Academy dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.
Apakah aku perlu pengalaman untuk memulai Java Academy?
Tidak diperlukan pengalaman sebelumnya. Java Academy di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 2 dari 4.
Berapa lama pelajaran “Kapan Paralelisme Membantu” memakan waktu?
Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.
Bisakah aku menulis dan menjalankan kode dalam pelajaran Java Academy ini?
Ya. Setiap pelajaran Java Academy menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.
Semua pelajaran dalam kursus ini
- Membuat Stream Paralel
- Kapan Paralelisme Membantu
- Keamanan Thread dan Efek Samping
- Kesalahan Umum