Multithreading omogućava Java programu da izvršava više niti istovremeno, omogućavajući paralelizam (korištenje više CPU jezgri) i odzivnost (obavljanje posla bez blokiranja). Java ima ugrađenu podršku za niti — ali zajednička mutable stanja uvode kompleksnost (race conditions) koja mora biti pažljivo upravljana.
() -> System.out.println( + Thread.currentThread().getName());
(task);
t.start();
Executors.newFixedThreadPool();
executor.submit(task);
Važna zamka: pozovite start() (pokreće novu nit), ne run() (što samo izvršava kod na trenutnoj niti sinkrono).
// ❌ 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 zapravo tri operacije (čitanje, inkrementiranje, pisanje). Kada se niti isprepletu, ažuriranja se gube — to je race condition. Ovo je glavni izazov konkurentnosti: zajedničko mutable stanje dostupno iz više niti bez 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 omogućava Java programima da koriste više jezgri i budu odzivni, ali je to ujedno jedno od najtežih područja koje treba da bude ispravno — race conditions iz nesinhroniziranog zajedničkog mutable stanja uzrokuju intermitentne, teško reproducibilne greške.
Razumijevanje kako niti funkcioniraju (start() vs run()), problem race-condition jezgre (zašto count++ nije sigurno), i alate za osiguranje sigurnosti (synchronized, atomic klase, concurrent kolekcije, immutability) je bitno za pisanje ispravnog konkurentnog koda.
Moderna najbolja praksa favorizira viši nivo apstrakcije (ExecutorService, CompletableFuture, virtualne niti) umjesto sirove upravljanja nitima.
Ovo je kritično znanje za serversku i visokoučinkovitu Javu, i duboka, često testirana tema koja odvaja kompetentne od stručnih razvojnih programera.