Java Academy · บทเรียน

เธรดเสมือนคืออะไร

เธรดน้ำหนักเบาใน Java 21

เธรดเสมือนคืออะไร เป็นบทเรียน Java Academy ฟรีบน CoddyKit นี่คือบทเรียนที่ 1 จากทั้งหมด 4 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน Java Academy และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส Java Academy มีบทเรียนทั้งหมด 4 บทเรียน

ยินดีต้อนรับสู่เธรดเสมือน

เธรดเสมือน เปิดตัวเป็นฟีเจอร์สมบูรณ์ใน Java 21 (JEP 444) เธรดเหล่านี้ได้รับการจัดการโดย JVM แทนระบบปฏิบัติการ

เป้าหมายเรียบง่าย: ให้คุณเขียนโค้ดแบบ หนึ่งเธรดต่อหนึ่งคำขอ ที่ตรงไปตรงมา พร้อมรองรับงานที่ทำงานพร้อมกันได้หลายล้านงาน

ปัญหาเดิม

เธรดแพลตฟอร์มแบบดั้งเดิมจะจับคู่แบบหนึ่งต่อหนึ่งกับเธรดของ OS แต่ละเธรดใช้หน่วยความจำสแตกประมาณหนึ่งเมกะไบต์และมีต้นทุนสูงในการสร้าง

นั่นหมายความว่าคุณจะทำงานพร้อมกันได้เพียงไม่กี่พันเธรด การดำเนินการรับส่งข้อมูลที่หยุดรอจะยึดเธรดของ OS ทั้งหมดไว้ขณะรอ

ความแตกต่างของเธรดเสมือน

เธรดเสมือนไม่ได้ครอบครองเธรดของ OS เธรดเสมือนจำนวนมากจะถูกจัดสรรสลับกันบนกลุ่มเธรดแพลตฟอร์ม พาหะ ขนาดเล็ก

สร้างได้ง่ายและมีต้นทุนต่ำ (หลายพันเธรดต่อมิลลิวินาที)
ใช้หน่วยความจำน้อยมาก
การหยุดรอจะพักเธรดเสมือนไว้ ทำให้เธรดพาหะว่าง

การเชื่อมต่อและถอดออก

เมื่อเธรดเสมือนทำงาน เธรดนั้นจะถูก เชื่อมต่อเข้ากับเธรดพาหะ เมื่อพบการดำเนินการที่ต้องหยุดรอ เธรดนั้นจะ ถอดออก และคืนเธรดพาหะเพื่อให้งานอื่นดำเนินต่อได้

การพักและทำงานต่อเช่นนี้เกิดขึ้นโดยอัตโนมัติ โค้ดของคุณจึงอ่านได้เหมือนโค้ดที่หยุดรอตามปกติ

เธรดเสมือนแรก

นี่คือตัวอย่างที่เรียบง่ายที่สุด Thread.ofVirtual().start(...) จะเริ่มเธรดเสมือน และ join() จะรอเธรดนั้น

public class Main {
    public static void main(String[] args) throws InterruptedException {
        Thread vt = Thread.ofVirtual().start(() ->
            System.out.println("Hello from a virtual thread!"));
        vt.join();
        System.out.println("Main is done.");
    }
}

ยืนยันว่าเป็นเธรดเสมือน

Thread ทุกตัวมี isVirtual() ให้ใช้ วิธีนี้ช่วยให้คุณตรวจสอบได้ว่าโค้ดกำลังทำงานอยู่บนเธรดประเภทใด

public class Main {
    public static void main(String[] args) throws InterruptedException {
        Thread vt = Thread.ofVirtual().start(() -> {
            System.out.println("isVirtual: " + Thread.currentThread().isVirtual());
        });
        vt.join();
    }
}

รองรับงานจำนวนมาก

เนื่องจากเธรดเสมือนมีต้นทุนต่ำ การเริ่มต้นใช้งานหลายหมื่นเธรดจึงเป็นเรื่องปกติอย่างสมบูรณ์ ในที่นี้เราจะเริ่มเธรดเสมือน 10,000 ตัว

import java.util.concurrent.atomic.AtomicInteger;

public class Main {
    public static void main(String[] args) throws InterruptedException {
        AtomicInteger counter = new AtomicInteger();
        Thread[] threads = new Thread[10_000];
        for (int i = 0; i < threads.length; i++) {
            threads[i] = Thread.ofVirtual().start(counter::incrementAndGet);
        }
        for (Thread t : threads) t.join();
        System.out.println("Completed: " + counter.get());
    }
}

การตั้งชื่อเธรดเสมือน

คุณสามารถตั้งชื่อเธรดเสมือนเพื่อให้แก้ไขข้อบกพร่องได้ง่ายขึ้น โดยใช้ตัวสร้างก่อนเริ่มเธรด

public class Main {
    public static void main(String[] args) throws InterruptedException {
        Thread vt = Thread.ofVirtual()
                .name("worker-1")
                .start(() ->
                    System.out.println("Running on: " + Thread.currentThread().getName()));
        vt.join();
    }
}

ส่วนติดต่อเดิม กลไกใหม่

เธรดเสมือนใช้ส่วนติดต่อ Thread แบบเดียวกับที่คุณรู้จักอยู่แล้วทุกประการ คุณยังคงใช้ start, join, sleep และ interrupt ได้

นั่นหมายความว่าไลบรารีเดิมที่สร้างบน Thread และ Runnable จะทำงานได้โดยไม่ต้องเปลี่ยนแปลง

ควรใช้เมื่อใด

เธรดเสมือนเหมาะอย่างยิ่งกับภาระงานที่ผูกกับการรับส่งข้อมูล เช่น เซิร์ฟเวอร์เว็บ การเรียกฐานข้อมูล และคำขอไปยังส่วนติดต่อโปรแกรมระยะไกล

เธรดเหล่านี้ไม่ได้ทำให้การคำนวณตัวเลขที่ผูกกับ CPU เร็วขึ้นแต่อย่างใด เพราะคุณยังคงถูกจำกัดด้วยจำนวนแกนประมวลผล

ไม่ใช่กลุ่มเธรด

แนวคิดสำคัญที่ต้องปรับเปลี่ยนคือ คุณไม่ควรรวมเธรดเสมือนไว้เป็นกลุ่ม ให้สร้างเธรดเสมือนใหม่สำหรับแต่ละงาน แล้วปล่อยให้เธรดจบลงเมื่องานเสร็จสิ้น

การรวมทรัพยากรเป็นกลุ่มมีไว้เพื่อใช้ทรัพยากรที่สร้างได้ยากซ้ำ แต่เธรดเสมือนสร้างได้ง่าย ดังนั้นการรวมเธรดเหล่านี้เป็นกลุ่มจึงเป็นรูปแบบการออกแบบที่ไม่ควรใช้

ตรวจสอบความเข้าใจอย่างรวดเร็ว

ทดสอบความเข้าใจของคุณเกี่ยวกับเธรดเสมือน

สรุป

คุณได้เรียนรู้ว่าเธรดเสมือนคืออะไรและมีความสำคัญอย่างไร:

มีน้ำหนักเบา จัดการโดย JVM และเปิดตัวอย่างสมบูรณ์ใน Java 21
ถูกจัดสรรให้ทำงานบนเธรดพาหะผ่านการแนบและถอดออก
เหมาะอย่างยิ่งกับงานที่ทำงานพร้อมกันจำนวนมากและผูกกับการรับส่งข้อมูล
ใช้ส่วนติดต่อเดียวกับ Thread แต่สร้างตามงานแทนที่จะรวมเป็นกลุ่ม

ถัดไป คุณจะได้เรียนรู้วิธีต่าง ๆ ในการสร้างเธรดเสมือน

คำถามที่พบบ่อย

บทเรียน “เธรดเสมือนคืออะไร” ฟรีหรือไม่

ใช่ — ข้อความเต็มของ “เธรดเสมือนคืออะไร” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7) และปลดล็อคส่วนที่เหลือของคอร์ส Java Academy ให้อัปเกรดเป็น CoddyKit PRO คอร์ส Java Academy มีบทเรียนทั้งหมด 4 บทเรียน

คุณจะเรียนรู้อะไรในบทเรียน “เธรดเสมือนคืออะไร”

เธรดน้ำหนักเบาใน Java 21 คุณปฏิบัติ Java Academy ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน

คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน Java Academy หรือไม่

ไม่จำเป็นต้องมีประสบการณ์มาก่อน Java Academy บน CoddyKit ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 1 จากทั้งหมด 4 บทเรียน

บทเรียน “เธรดเสมือนคืออะไร” ใช้เวลานานแค่ไหน

บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย

ฉันเขียนและรันโค้ดในบทเรียน Java Academy นี้ได้ไหม

ได้ บทเรียน Java Academy ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ

บทเรียนทั้งหมดในหลักสูตรนี้

← กลับไปที่ Java Academy