Paprèn multithreading nang-arep ing Java?

Question

Accepted Answer

**Multithreading** wayah program Java mamatèk masjad sakabèh thread sakaligus, ngamantaakèn parallelism (manggunaakèn loba core CPU) lan responsivitas (ngambalèkakèn gawean tanpa anèh). Java duwe dhukungan thread katon pertamà — nanging kayadyan mutabel disisik pambukakèn rèmèn (race condition) kudu diaturèn kanthi celik. ## Nggawèakèn thread ```java // 1. Implement Runnable (preferred — separates task from thread) Runnable task = () -> System.out.println("running on " + Thread.currentThread().getName()); Thread t = new Thread(task); t.start(); // start() runs it on a NEW thread (run() would run on the CURRENT thread!) // 2. modern: use an ExecutorService instead of raw threads ExecutorService executor = Executors.newFixedThreadPool(4); executor.submit(task); ``` **Gotcha penting:** takonèk `start()` (ngambukaakèn thread anyar), dudu `run()` (kang wangsul nglaksanaakèn kode ing thread saiki sacara sinkron). ## Èntang perkara inti: race condition ```java // ❌ multiple threads modifying shared state → unpredictable results class Counter { int count = 0; void increment() { count++; } // NOT atomic: read → add → write (can interleave) } // 1000 threads each incrementing 1000 times → final count is often < 1,000,000! ``` `count++` inggih menika telung operasi (waca, nambah, tulis). Bilih thread saling ngajar, kadangkali nganti kewat — **race condition**. Iki dadi kayadyan pusat ing concurrency: kayadyan mutabel disisik kang diakses loba thread tanpa koordinasi. ## Solusèn kanggo kayadyan disisik kang aman ```java // 1. synchronized — only one thread in the method/block at a time (a lock) synchronized void increment() { count++; } // 2. atomic classes — lock-free atomic operations AtomicInteger count = new AtomicInteger(0); count.incrementAndGet(); // atomic, thread-safe, efficient // 3. concurrent collections — built for multi-threaded access ConcurrentHashMap map = new ConcurrentHashMap<>(); // 4. immutability — immutable objects are inherently thread-safe (nothing to corrupt) ``` ## Koordinasi thread ```java t.join(); // wait for thread t to finish Thread.sleep(1000); // pause the current thread // also: wait()/notify(), CountDownLatch, locks, etc. for coordination ``` ## Cara modern: aja memanage thread bodhom ```text ✓ Use ExecutorService / thread pools (not new Thread() per task — expensive) ✓ Use CompletableFuture for async composition ✓ Use concurrent collections and atomic classes over manual synchronization ✓ Java 21+ adds Virtual Threads — millions of lightweight threads for I/O concurrency ``` ## Menapa iki wigati Multithreading wadharakèn program Java manahkakèn loba core lan tetap responsif, nanging iki uga dadi salah sakmadyan wètènan paling angel kanggo bener — **race condition** saka kayadyan mutabel disisik tanpa sinkronisasi ndadharakèn bug intermittent lan angel dibaleni. Ngèrti bab cara kerja thread (`start()` vs `run()`), perkara race condition inti (menapa `count++` ora aman), lan piranti kanggo mutusèn kapéstèn (`synchronized`, atomic class, concurrent collection, immutability) minangka bagéan penting kanggo nulis kode concurrent kang bener. Praktik terbaik modern nggegem abstraksi tingkat luwih inggil (ExecutorService, CompletableFuture, virtual thread) tinimbang management thread bodhom. Iki kayadyan penting kanggo Java sisih server lan dhuwur kinerja, lan topik mandhala lan sering diuji kang nggawèakèn padhang antarane developer kompéten lan ahli.