Bagaimana cara kerja multithreading di Java?

Question

Accepted Answer

**Multithreading** memungkinkan program Java menjalankan beberapa thread secara bersamaan, memungkinkan paralelisme (menggunakan beberapa inti CPU) dan responsivitas (melakukan pekerjaan tanpa pemblokiran). Java memiliki dukungan thread tingkat pertama — tetapi shared mutable state memperkenalkan kompleksitas (race conditions) yang harus dikelola dengan hati-hati. ## Membuat threads ```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:** panggil `start()` (spawn thread baru), bukan `run()` (yang hanya menjalankan kode pada thread saat ini secara sinkron). ## Masalah inti: race conditions ```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++` sebenarnya tiga operasi (baca, increment, tulis). Ketika threads saling sisip, update hilang — sebuah **race condition**. Ini adalah tantangan utama concurrency: shared mutable state diakses oleh beberapa thread tanpa koordinasi. ## Solusi untuk shared state yang 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 ``` ## Pendekatan modern: jangan kelola raw threads ```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 ``` ## Mengapa ini penting Multithreading memungkinkan program Java menggunakan beberapa inti dan tetap responsif, tetapi juga merupakan salah satu area paling sulit untuk dilakukan dengan benar — **race conditions** dari shared mutable state yang tidak disinkronkan menyebabkan bug yang intermiten dan sulit direproduksi. Memahami cara kerja threads (`start()` vs `run()`), masalah race condition inti (mengapa `count++` tidak aman), dan alat untuk memastikan keamanan (`synchronized`, atomic classes, concurrent collections, immutability) sangat penting untuk menulis concurrent code yang benar. Praktik best practice modern lebih memilih abstraksi tingkat lebih tinggi (ExecutorService, CompletableFuture, virtual threads) daripada raw thread management. Ini adalah pengetahuan kritis untuk server-side dan high-performance Java, serta topik yang sering diuji dan mendalam yang membedakan developer yang kompeten dari yang ahli.