Java Academy · บทเรียน

โมเดลการทำงานพร้อมกันแบบมีโครงสร้าง

จัดการงานที่เกี่ยวข้องเป็นหน่วยเดียว

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

การทำงานพร้อมกันแบบมีโครงสร้างคืออะไร

การทำงานพร้อมกันแบบมีโครงสร้าง (JEP 453 รุ่นทดลอง) ถือว่างานพร้อมกันที่เกี่ยวข้องกันกลุ่มหนึ่งเป็นหน่วยงานเดียว

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

ปัญหาที่วิธีนี้แก้ไข

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

สิ่งนี้นำไปสู่เธรดรั่วไหล งานที่ไม่มีผู้ดูแล และการจัดการความล้มเหลวที่สับสน

งานในรูปแบบต้นไม้

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

งานย่อยไม่สามารถมีอายุการทำงานยาวนานกว่าขอบเขตของงานหลัก
งานหลักจะรอให้งานย่อยทั้งหมดเสร็จสิ้น
การยกเลิกจะไหลลงไปตามต้นไม้

สะท้อนโค้ดแบบลำดับขั้น

แนวคิดสำคัญคือ โค้ดที่ทำงานพร้อมกันควรอ่านได้เหมือนโค้ดแบบลำดับขั้น ขอบเขตเริ่มต้น งานถูกแยกไปทำพร้อมกัน และขอบเขตจะปิดลงก็ต่อเมื่อทุกอย่าง join เสร็จแล้ว

วิธีนี้ทำให้อายุการทำงานมองเห็นได้ชัดเจนและทำความเข้าใจข้อผิดพลาดได้ง่าย

แนวทางแบบไม่มีโครงสร้างในอดีต

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

import java.util.concurrent.*;

public class Main {
    public static void main(String[] args) throws Exception {
        try (ExecutorService exec = Executors.newVirtualThreadPerTaskExecutor()) {
            Future<String> user = exec.submit(() -> "Ada");
            Future<Integer> order = exec.submit(() -> 7);
            System.out.println(user.get() + " has " + order.get() + " orders");
        }
    }
}

เหตุใดการประสานงานจึงสำคัญ

ในตัวอย่างก่อนหน้านี้ หากการดึงข้อมูลผู้ใช้ล้มเหลว งานเรียงลำดับจะยังคงทำงานต่อไปโดยเปล่าประโยชน์ คุณต้องยกเลิกงานนั้นด้วยตนเองและจัดการข้อยกเว้นจาก get() แต่ละรายการ

การทำงานพร้อมกันแบบมีโครงสร้างทำให้การประสานงานนี้เป็นไปโดยอัตโนมัติ

สถานะรุ่นทดลอง

การทำงานพร้อมกันแบบมีโครงสร้างมาพร้อมส่วนติดต่อการเขียนโปรแกรมรุ่นทดลองในชุด java.util.concurrent หากต้องการใช้ คุณต้องคอมไพล์และเรียกใช้ด้วย --enable-preview

คลาสหลักคือ StructuredTaskScope ซึ่งจะกล่าวถึงในบทเรียนถัดไป

การรับประกันอายุการใช้งาน

ภายใน scope ที่มีโครงสร้าง:

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

ประโยชน์ด้านการสังเกตการณ์

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

ทำงานเข้ากันได้ดีกับเธรดเสมือน

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

คุณลักษณะทั้งสองได้รับการออกแบบมาให้ทำงานร่วมกันอย่างใกล้ชิด

แบบจำลองทางความคิด

ลองนึกภาพ scope ที่มีโครงสร้างเหมือนบล็อก try พร้อมการจัดการทรัพยากรสำหรับการทำงานพร้อมกัน: คุณเปิด scope นั้น แยกงานด้วย fork รอด้วย join แล้วจึงปิด การปิดวงเล็บปีกกาคือการรับประกันว่าไม่มีสิ่งใดเหลือทำงานอยู่

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

ทดสอบความเข้าใจหลักการสำคัญของคุณ

สรุปทบทวน

คุณได้ทำความรู้จักแบบจำลองการทำงานพร้อมกันแบบมีโครงสร้าง:

งานที่เกี่ยวข้องกันรวมเป็นต้นไม้ที่ผูกกับอายุการใช้งานของ scope
โค้ดที่ทำงานพร้อมกันอ่านได้เหมือนโค้ดที่ทำงานตามลำดับ
นี่คือส่วนติดต่อโปรแกรมประยุกต์รุ่นทดลองที่ต้องใช้ --enable-preview
ทำงานเข้าคู่กับเธรดเสมือนได้อย่างเป็นธรรมชาติ

ถัดไป: ส่วนติดต่อโปรแกรมประยุกต์ StructuredTaskScope โดยตรง

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

บทเรียน “โมเดลการทำงานพร้อมกันแบบมีโครงสร้าง” ฟรีหรือไม่

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

คุณจะเรียนรู้อะไรในบทเรียน “โมเดลการทำงานพร้อมกันแบบมีโครงสร้าง”

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

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

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

บทเรียน “โมเดลการทำงานพร้อมกันแบบมีโครงสร้าง” ใช้เวลานานแค่ไหน

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

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

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

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

โมเดลการทำงานพร้อมกันแบบมีโครงสร้าง
StructuredTaskScope
การปิดเมื่อเกิดความล้มเหลวและเมื่อสำเร็จ
การจัดการข้อผิดพลาดและการยกเลิก

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