Si funksionon multithreading në Java?

Question

Accepted Answer

**Multithreading** lejon një program Java të ekzekutojë disa rrjedhje të ekzekutimit njëkohësisht, duke mundësuar paralelizmin (duke përdorur disa bërthama CPU) dhe përgjigjen (duke kryer punë pa u bllokuar). Java ka mbështetje të rendit të parë për rrjedhjet — por gjendja e ndashme dhe e ndryshueshme përdor kompleksitet (kushte garimi) që duhet të menaxhohen me kujdes. ## Krijimi i rrjedhave ```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); ``` **Kurth themelor:** thirr `start()` (krijon një rrjedhë të re), jo `run()` (e cila vetëm ekzekuton kodin në rrjedhën aktuale në mënyrë sinkrone). ## Problemi themelor: kushtet e garimit ```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++` është në fakt tre operacione (lexim, rritje, shkrim). Kur rrjedhjet ndërthurren, përditësimet humbin — një **kusht garimi**. Ky është sfida qendrore e konkurencës: gjendje e ndashme dhe e ndryshueshme e aksesuar nga rrjedhje të shumta pa koordinim. ## Zgjidhje për gjendjen e ndashme të sigurt ```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) ``` ## Koordinimi i rrjedhave ```java t.join(); // wait for thread t to finish Thread.sleep(1000); // pause the current thread // also: wait()/notify(), CountDownLatch, locks, etc. for coordination ``` ## Qasja moderne: mos menaxho rrjedhje të papërpunuara ```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 ``` ## Pse është e rëndësishme Multithreading lejon programet Java të përdorin disa bërthama dhe të mbeten përgjigimtare, por është gjithashtu një nga fushat më të vështira për ta bërë siç duhet — **kushtet e garimit** nga gjendje e ndashme dhe e ndryshueshme e pa sinkronizuar shkaktojnë gabime të ndërmitshme, të vështira për të riprodhuar. Përkuptimi i mënyrës se si funksionojnë rrjedhjet (`start()` kundrejt `run()`), problemi themelor i kushtit të garimit (pse `count++` nuk është i sigurt) dhe mjetet për të siguruar sigurinë (`synchronized`, klasat atomike, koleksione konkurrente, përmarrja e pandryshueshme) është thelbësor për shkruarjen e kodit të saktë konkurrues. Praksa moderne favorizon abstraksione më të larta (ExecutorService, CompletableFuture, rrjedhje virtuale) mbi menaxhimin e rrjedhave të papërpunuara. Ky është njohuri kritike për Java të anës së serverit dhe të lartë-performante, dhe një temë e thellë, shpesh e testuar, që ndan zhvilluesit e kompetent nga ata ekspertë.