Conas a oibríonn iolthréadú i Java?

Question

Accepted Answer

**Iolthréadú** a bhíonn in ann do phlé Java rith iolraí snáitheanna go comhthréimhsiúil, ag cumasú paraileachais (ag baint úsáide as iolraí CPU cores) agus freagúlachta (obair a dhéanamh gan bhlocáil). Tá tacaíocht snáithe den chéad-scéim ag Java — ach bíonn staid inathraitheach roinnte i gcomhrac casta (coinníollacha rása) a chaithfear a bhainistiú go cúramach. ## Snáitheanna a chruthú ```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); ``` **Gotcha príomhúil:** glaoch ar `start()` (spréachann snáithe nua), ní `run()` (a rithíonn an cód ar an snáithe reatha go sioncronach i ngan fhios). ## An fhadhb bhunúsach: coinníollacha rása ```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++` trí oibríochtaí go fírinne (léamh, méadú, scríobh). Nuair a bhíonn snáitheanna ag gealadh, cailltear nuashonruithe — **coinníollacha rása**. Is é seo an dúshlán lárnach ar chomhthreomhaireacht: staid inathraitheach roinnte ag iolraí snáitheanna gan chomhordú. ## Réitigh do staid roinnte shábháilte ```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) ``` ## Comhordú snáithe ```java t.join(); // wait for thread t to finish Thread.sleep(1000); // pause the current thread // also: wait()/notify(), CountDownLatch, locks, etc. for coordination ``` ## An cur chuige nua-aimseartha: ná bainistigh snáitheanna amh ```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 ``` ## Cén fáth a bhíonn sé i gceist Ligíonn iolthréadú do phláig Java iolraí cores a úsáid agus fanacht freagúil, ach is é ceann de na raonta is deacra a fháil ceart — **coinníollacha rása** ó staid inathraitheach roinnte gan sioncronú a bharraig cluichí doiléire, deacair-atáirgeadh. Tuiscint ar conas a oibríonn snáitheanna (`start()` vs `run()`), an fhadhb choinníollacha rása (cén fáth nach bhfuil `count++` sábháilte), agus na huirlisí a chinntiú a shábháilteacht (`synchronized`, aicmí adamhach, bailiúchán comhthreomhairc, neamh-athraitheacht) ríthábhachtach do chód ceart comhthreomhaire a scríobh. Is fearr i gcleachtas nua-aimseartha gné dhéanta níos airde (ExecutorService, CompletableFuture, snáitheanna fíorúla) ar bhainistíocht snáithe amh. Is eolas criticiúil é seo do Java taobh an fhreastalaí agus ard-fheidhmíochta, agus ábhar domhain, minic-thástáilte a scarann forbróirí ábalta ó easpórtanna.