Kif jaħdem il-multithreading f'Java?

Question

Accepted Answer

**Il-multithreading** jippermetti programm Java jaħdem threads multipli simultanjament, li jipprovdi parallelizmu (bl-użu ta' cores multipli tal-CPU) u responsività (magħmul tax-xogħol mingħajr blokk). Java għandu appoġġ ta' threads ta' prim-klassi — imma l-istati mutable imqassma jintroduċu kumplessità (race conditions) li għandhom jitwesslu b'ħarsa. ## Ħolqod 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); ``` **Avvertiment importanti:** sejjaħ `start()` (iniċji thread ġdid), mhux `run()` (li sempliċement iċċedi l-kodiċi fuq it-thread attwali b'mod sinkronu). ## Il-problema ċentrali: 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++` huwa fil-fatt tliet operazzjonijiet (qari, increment, kitba). Meta threads jiddiskonnettaw, l-aġġornamenti jitilfu — **race condition**. Din hija l-isfida ċentrali tal-concurrency: stat mutable imqassam aċċessat minn threads multipli mingħajr koordinazzjoni. ## Soluzzjonijiet għal stat imqassam sigur ```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) ``` ## Koordinazzjoni ta' threads ```java t.join(); // wait for thread t to finish Thread.sleep(1000); // pause the current thread // also: wait()/notify(), CountDownLatch, locks, etc. for coordination ``` ## L-approċċ modern: la titwesslu threads mhux immexxi ```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 ``` ## Għaliex dan importanti Il-multithreading jippermetti programmi Java jużaw cores multipli u jibqgħu responsivi, imma huwa wkoll wieħed mill-areas l-aktar diffiċili biex tagħmel sew — **race conditions** minn stat mutable imqassam mhux sinkronizzat jikkawżaw bugs intermittent u diffiċli biex jiġu riprodotti. L-għarif kif jaħdmu threads (`start()` vs `run()`), il-problema ċentrali tar-race condition (għaliex `count++` mhuwiex sigur), u l-għodod biex tiġi żgurata s-sigurezza (`synchronized`, atomic classes, concurrent collections, immutability) huwa essenzjali għall-kitba ta' kodiċi concurrency korrett. Il-prattika l-aħjar moderna tippreferenzi astrazzjonijiet ta' livell ogħla (ExecutorService, CompletableFuture, virtual threads) fuq il-ġestjoni ta' threads mhux immexxi. Hada hija għarifa kritika għall-Java tal-lat server u ta' prestazzjoni għolja, u suġġett profond u ħafna mmexxi li jiddistingwi l-iżviluppaturi kompetenți minn dawk esperti.