Bagaimana multithreading berfungsi dalam Java?

Question

Accepted Answer

**Multithreading** memungkinkan program Java menjalankan beberapa thread secara bersamaan, memberikan paralelisme (menggunakan beberapa inti CPU) dan responsivitas (melakukan pekerjaan tanpa blokir). Java memiliki dukungan thread tingkat pertama — tetapi status yang dapat diubah bersama memperkenalkan kompleksitas (kondisi perlombaan) yang harus dikelola dengan hati-hati. ## Membuat 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:** panggil `start()` (melahirkan thread baru), bukan `run()` (yang hanya menjalankan kode pada thread saat ini secara sinkron). ## Masalah inti: kondisi perlombaan ```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, kenaikan, tulis). Ketika thread saling menyela, pembaruan hilang — **kondisi perlombaan**. Ini adalah tantangan pusat konkurensi: status yang dapat diubah bersama diakses oleh beberapa thread tanpa koordinasi. ## Solusi untuk status bersama 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 mengelola thread mentah ```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 itu juga salah satu area paling sulit untuk dilakukan dengan benar — **kondisi perlombaan** dari status yang dapat diubah bersama yang tidak disinkronkan menyebabkan bug intermiten yang sulit direproduksi. Memahami cara kerja thread (`start()` vs `run()`), masalah kondisi perlombaan inti (mengapa `count++` tidak aman), dan alat untuk memastikan keselamatan (`synchronized`, kelas atomik, koleksi konkuren, immutability) sangat penting untuk menulis kode konkuren yang benar. Praktik terbaik modern lebih menyukai abstraksi tingkat lebih tinggi (ExecutorService, CompletableFuture, thread virtual) daripada manajemen thread mentah. Ini adalah pengetahuan penting untuk Java sisi server dan berkinerja tinggi, dan topik yang mendalam dan sering diuji yang membedakan pengembang yang kompeten dari pengembang ahli.