Multithreading umožňuje Java programu spouštět více vláken souběžně, což umožňuje paralelismus (použití více CPU jader) a responsivnost (provádění práce bez blokování). Java má podporu vláken první třídy — ale sdílený měnitelný stav zavádí složitost (race conditions), kterou je třeba pečlivě spravovat.
() -> System.out.println( + Thread.currentThread().getName());
(task);
t.start();
Executors.newFixedThreadPool();
executor.submit(task);
Klíčová pozornost: volejte start() (vytvoří nové vlákno), ne run() (která pouze spustí kód na aktuálním vlákně synchronně).
// ❌ 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 vlastně tři operace (čtení, inkrementace, zápis). Když se vlákna proloží, aktualizace se ztratí — race condition. Toto je ústředním problémem konkurence: sdílený měnitelný stav přístupný více vlákny bez koordinace.
// 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 umožňuje Java programům využívat více jader a zůstat responsivní, ale je to také jedna z nejtěžších oblastí, ve které dosáhnout správného výsledku — race conditions z nesynchronizovaného sdíleného měnitelného stavu způsobují intermitentní, těžko reprodukovatelné chyby.
Porozumění tomu, jak vlákna fungují (start() vs run()), základní problém race-condition (proč count++ není bezpečné), a nástroje pro zajištění bezpečnosti (synchronized, atomické třídy, souběžné kolekce, imutabilita) jsou nezbytné pro psaní správného souběžného kódu.
Moderní osvědčená praxe dává přednost abstrakci vyšší úrovně (ExecutorService, CompletableFuture, virtuální vlákna) před správou surových vláken.
Toto je kritické znalosti pro serverový a vysokovýkonný Java kód, a hluboké, často testované téma, které odlišuje kompetentní od zkušených vývojářů.
Knihovna IT otázek k pohovoru s podrobnými odpověďmi — od Junior po Senior.
Přispět