Multithreading omogoča Java programu, da teče več niti sočasno, kar omogoča paralelizem (uporaba več jedier CPU-ja) in odzivnost (opravljanje dela brez blokiranja). Java ima prvo-razredno podporo za niti — vendar skupno spremenljivo stanje uvaja kompleksnost (race pogoji), ki jih je treba pazljivo upravljati.
() -> System.out.println( + Thread.currentThread().getName());
(task);
t.start();
Executors.newFixedThreadPool();
executor.submit(task);
Ključna past: kliči start() (ustvari novo nit), ne run() (kar samo požene kodo na trenutni niti sinhronsko).
// ❌ 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++ je dejansko tri operacije (branje, povečanje, pisanje). Ko se niti prepletajo, posodobitve se izgubijo — race pogoj. To je osrednji izziv konkurentnosti: skupno spremenljivo stanje, dostopano s strani več niti brez koordinacije.
// 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<String, Integer> map = new ConcurrentHashMap<>();
// 4. immutability — immutable objects are inherently thread-safe (nothing to corrupt)
t.join(); // wait for thread t to finish
Thread.sleep(1000); // pause the current thread
// also: wait()/notify(), CountDownLatch, locks, etc. for coordination
✓ 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
Multithreading omogoča Java programom, da uporabljajo več jedier in ostanejo odzivni, vendar je to tudi eno najtežjih področij za pravilno izvedbo — race pogoji iz nesinhroniziranega skupnega spremenljivega stanja povzročajo prekinčne, težko reproducirljive napake.
Razumevanje, kako niti delujejo (start() protiv run()), osrednjenega problema race pogoja (zakaj count++ ni varno) in orodij za zagotovitev varnosti (synchronized, atomske razrede, sočasne kolekcije, nespremenljivost) je bistveno za pisanje pravilne konkurentne kode.
Moderna best practice favorizira abstraktne abstrakcije na višji ravni (ExecutorService, CompletableFuture, virtualne niti) pred upravljanjem surovih niti.
To je kritično znanje za strežniško in visoko-zmogljivo Javo ter poglobljeno, pogosto testirano temo, ki ločuje kompetentne od strokovnih razvijalcev.