Multithreading ทำงานอย่างไรใน Java?

Question

Accepted Answer

**Multithreading** ช่วยให้โปรแกรม Java สามารถรันหลาย thread พร้อมกันได้ เพื่อเปิดใจให้กับการประมวลผลแบบขนาน (ใช้ CPU cores หลายตัว) และความรับผิดชอบ (ทำงานโดยไม่ถูกบล็อก) Java มี first-class support สำหรับ threads — แต่สถานะที่ร่วมกันและเปลี่ยนแปลงได้นั้นนำมาซึ่งความซับซ้อน (race conditions) ที่ต้องจัดการอย่างระมัดระวัง ## การสร้าง threads ```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 สำคัญ:** เรียก `start()` (สร้าง thread ใหม่) ไม่ใช่ `run()` (ซึ่งเพียงแค่รันโค้ดบน thread ปัจจุบันแบบซิงโครนัส) ## ปัญหาหลัก: race conditions ```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++` คือการดำเนินการสามขั้นตอน (อ่าน เพิ่มขึ้น เขียน) เมื่อ threads 交차, การอัพเดตจะหายไป — **race condition** นี่คือความท้าทายหลักของการพร้อมกัน: สถานะที่ร่วมกันและเปลี่ยนแปลงได้ที่หลาย threads เข้าถึงโดยไม่มีการประสานงาน ## โซลูชันสำหรับสถานะที่ร่วมกันอย่างปลอดภัย ```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) ``` ## การประสานงาน Thread ```java t.join(); // wait for thread t to finish Thread.sleep(1000); // pause the current thread // also: wait()/notify(), CountDownLatch, locks, etc. for coordination ``` ## แนวทางสมัยใหม่: อย่าจัดการ raw threads ```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 ``` ## ทำไมจึงสำคัญ Multithreading ช่วยให้โปรแกรม Java ใช้ CPU cores หลายตัวและตอบสนองได้ดี แต่นี่ก็เป็นหนึ่งในพื้นที่ที่ยากที่สุดในการปฏิบัติให้ถูกต้อง — **race conditions** จากสถานะที่ร่วมกันและเปลี่ยนแปลงได้ที่ไม่ได้ซิงโครไนซ์ทำให้เกิดบักที่ยากต่อการทำซ้ำ การเข้าใจว่า threads ทำงานอย่างไร (`start()` vs `run()`), ปัญหาหลัก race condition (ทำไม `count++` ไม่ปลอดภัย) และเครื่องมือเพื่อให้มั่นใจว่าปลอดภัย (`synchronized` atomic classes concurrent collections immutability) เป็นสิ่งจำเป็นสำหรับการเขียนโค้ดพร้อมกันที่ถูกต้อง บริหารอย่างดีที่สุดสมัยใหม่ชอบ abstractions ระดับสูง (ExecutorService CompletableFuture virtual threads) มากกว่าการจัดการ raw threads นี่คือความรู้ที่สำคัญสำหรับ server-side และ high-performance Java และหัวข้อที่ลึกซึ้ง มักถูกทดสอบ ที่แยกแยะระหว่างนักพัฒนาผู้มีความสามารถกับผู้เชี่ยวชาญ