รูปแบบไปป์ไลน์และขั้นตอน
ประกอบไปป์ไลน์พร้อมกันหลายขั้นตอน
รูปแบบไปป์ไลน์และขั้นตอน เป็นบทเรียน Go Academy ฟรีบน CoddyKit นี่คือบทเรียนที่ 1 จากทั้งหมด 4 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน Go Academy และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส Go Academy มีบทเรียนทั้งหมด 4 บทเรียน
ไปป์ไลน์คืออะไร
ไปป์ไลน์แบบทำงานพร้อมกันคือชุดของ stage ที่เชื่อมต่อกันด้วยช่องสัญญาณ แต่ละ stage รับค่าจากต้นทาง แปลงค่าเหล่านั้น แล้วส่งผลลัพธ์ไปยังปลายทาง ทำให้ stage ต่าง ๆ ทำงานพร้อมกันได้
ไปป์ไลน์สาม stage แบบง่าย
generate → แปลง → ใช้งาน:
func generate(nums ...int) <-chan int {
out := make(chan int)
go func() { defer close(out); for _, n := range nums { out <- n } }()
return out
}
func square(in <-chan int) <-chan int {
out := make(chan int)
go func() { defer close(out); for n := range in { out <- n*n } }()
return out
}
for v := range square(generate(2, 3, 4)) {
fmt.Println(v) // 4, 9, 16
}รูปแบบ stage
แต่ละ stage เป็นฟังก์ชันที่รับช่องสัญญาณอินพุตและส่งคืนช่องสัญญาณเอาต์พุต สามารถประกอบ stage ต่าง ๆ ได้อย่างเป็นระเบียบ และทำงานแบบขนานแยกจากกันได้
การแตกแขนงภายในไปป์ไลน์
แยก stage ออกเป็นโกโรทีน N ตัวเพื่อทำงานที่ใช้ CPU หนักแบบขนาน:
func parallelSquare(in <-chan int, n int) <-chan int {
outs := make([]<-chan int, n)
for i := 0; i < n; i++ {
outs[i] = square(in) // all read from same in
}
return merge(outs...)
}การยกเลิกด้วยบริบท
ส่งบริบทไปยังแต่ละ stage เมื่อบริบทถูกยกเลิก stage จะหยุดอ่านและปิดช่องสัญญาณเอาต์พุตของตน เพื่อระบายข้อมูลออกจากไปป์ไลน์ทั้งหมด
func stage(ctx context.Context, in <-chan int) <-chan int {
out := make(chan int)
go func() {
defer close(out)
for {
select {
case v, ok := <-in:
if !ok { return }
select {
case out <- process(v):
case <-ctx.Done(): return
}
case <-ctx.Done(): return
}
}
}()
return out
}แรงดันย้อนกลับ
ใช้ช่องสัญญาณแบบมีบัฟเฟอร์ระหว่าง stage เพื่อแยกความเร็วของผู้ผลิตและผู้บริโภคออกจากกัน หากไม่มีบัฟเฟอร์ stage ที่ทำงานช้าจะทำให้ไปป์ไลน์ทั้งหมดหยุดรอ
out := make(chan Result, 50) // buffer 50 resultsการส่งต่อข้อผิดพลาด
ห่อค่าไว้ในโครงสร้างผลลัพธ์เพื่อส่งต่อข้อผิดพลาดผ่านไปป์ไลน์โดยไม่ทำให้โปรแกรมหยุดทำงานด้วย panic:
type item struct { val int; err error }รูปแบบช่องสัญญาณ Done
ใช้ช่องสัญญาณ Done เป็นทางเลือกแทนบริบทสำหรับไปป์ไลน์ที่ง่ายกว่า ปิด done เพื่อส่งสัญญาณให้ทุก stage หยุดทำงาน
done := make(chan struct{})
defer close(done)การรับประกันลำดับ
ไปป์ไลน์แบบง่ายจะรักษาลำดับไว้หากแต่ละ stage ทำงานตามลำดับ stage ที่ทำงานแบบขนานจะไม่รักษาลำดับ หากจำเป็น ให้ใช้ฟิลด์ดัชนีเพื่อจัดเรียงผลลัพธ์ใหม่ที่ปลายทาง
ไปป์ไลน์กับ WaitGroup
stage สุดท้ายไม่จำเป็นต้องปิดช่องสัญญาณ เพียงวนอ่านค่าจากช่องนั้น ใช้ WaitGroup ในการรวมช่องสัญญาณเพื่อปิดช่องสัญญาณที่รวมแล้วหลังจากโกโรทีนผู้ผลิตทั้งหมดทำงานเสร็จ
การใช้งานจริง
การใช้งานไปป์ไลน์ที่พบบ่อย ได้แก่ การประมวลผลข้อมูล ETL การปรับขนาดรูปภาพ การแยกวิเคราะห์บันทึก ระบบสร้าง และตัวจัดการคำขอแบบสตรีม
ตรวจสอบอย่างรวดเร็ว
คุณจะส่งต่อการยกเลิกผ่านไปป์ไลน์ที่มีหลาย stage ได้อย่างไร
สรุป: รูปแบบไปป์ไลน์
ประเด็นสำคัญ:
- stage: func(in <-chan T) <-chan U — นำมาประกอบกันเพื่อสร้างไปป์ไลน์
- การยกเลิกทำผ่านบริบท ส่วนแรงดันย้อนกลับทำผ่านช่องสัญญาณแบบมีบัฟเฟอร์
- แตกแขนงภายใน stage เพื่อทำงานแบบขนาน
- ห่อค่าไว้ในโครงสร้างผลลัพธ์เพื่อส่งต่อข้อผิดพลาด
คำถามที่พบบ่อย
บทเรียน “รูปแบบไปป์ไลน์และขั้นตอน” ฟรีหรือไม่
ใช่ — ข้อความเต็มของ “รูปแบบไปป์ไลน์และขั้นตอน” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7) และปลดล็อคส่วนที่เหลือของคอร์ส Go Academy ให้อัปเกรดเป็น CoddyKit PRO คอร์ส Go Academy มีบทเรียนทั้งหมด 4 บทเรียน
คุณจะเรียนรู้อะไรในบทเรียน “รูปแบบไปป์ไลน์และขั้นตอน”
ประกอบไปป์ไลน์พร้อมกันหลายขั้นตอน คุณปฏิบัติ Go Academy ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน
คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน Go Academy หรือไม่
ไม่จำเป็นต้องมีประสบการณ์มาก่อน Go Academy บน CoddyKit ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 1 จากทั้งหมด 4 บทเรียน
บทเรียน “รูปแบบไปป์ไลน์และขั้นตอน” ใช้เวลานานแค่ไหน
บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย
ฉันเขียนและรันโค้ดในบทเรียน Go Academy นี้ได้ไหม
ได้ บทเรียน Go Academy ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ
บทเรียนทั้งหมดในหลักสูตรนี้
- รูปแบบไปป์ไลน์และขั้นตอน
- errgroup สำหรับจัดการข้อผิดพลาดพร้อมกัน
- รูปแบบเซมาฟอร์
- การตรวจจับการรั่วไหลและการยกเลิก