Go Academy · บทเรียน

ขั้นตอนของกระบวนการประมวลผล

เชื่อมขั้นตอนของแชนเนล

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

ไปป์ไลน์คืออะไร

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

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

รูปแบบลายเซ็นของ stage

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

func stage(in <-chan int) <-chan int {
    out := make(chan int)
    go func() {
        defer close(out)
        for v := range in {
            out <- v
        }
    }()
    return out
}

stage แหล่งข้อมูล

stage แรกทำหน้าที่สร้างข้อมูล โดยมักรับสไลซ์หรืออาร์กิวเมนต์แบบแปรผันจำนวนได้ แล้วส่งข้อมูลเหล่านั้นเข้าแชนเนลอย่างต่อเนื่อง

func numbers(vals ...int) <-chan int {
    out := make(chan int)
    go func() {
        defer close(out)
        for _, v := range vals {
            out <- v
        }
    }()
    return out
}

stage แปลงข้อมูล

stage นี้คูณทุกค่าด้วยสิบ โดยอ่านจาก in และเขียนค่าที่แปลงแล้วไปยัง out

func tenfold(in <-chan int) <-chan int {
    out := make(chan int)
    go func() {
        defer close(out)
        for v := range in {
            out <- v * 10
        }
    }()
    return out
}

stage กรองข้อมูล

ตัวกรองจะส่งต่อเฉพาะค่าที่ตรงตามเงื่อนไขเท่านั้น ในที่นี้เราจะเก็บตัวเลขคู่และทิ้งค่าที่เหลือ

func evens(in <-chan int) <-chan int {
    out := make(chan int)
    go func() {
        defer close(out)
        for v := range in {
            if v%2 == 0 {
                out <- v
            }
        }
    }()
    return out
}

การต่อ stage เข้าด้วยกัน

ประกอบ stage โดยส่งผลลัพธ์ของ stage หนึ่งไปเป็นข้อมูลเข้าของ stage ถัดไป การต่อแบบนี้อ่านได้เกือบเหมือนประโยคหนึ่งประโยค

pipe := tenfold(evens(numbers(1, 2, 3, 4)))
for v := range pipe {
    fmt.Println(v)
}

defer close(out)

การใช้ defer close(out) รับประกันว่าแชนเนลผลลัพธ์จะถูกปิดเมื่อกอรูทีนของ stage ส่งคืนค่า แม้ภายหลังคุณจะเพิ่มการส่งคืนค่าก่อนกำหนด วิธีนี้จะส่งสัญญาณสิ้นสุดกระแสข้อมูลต่อไปยังปลายทาง

ไปป์ไลน์อย่างสมบูรณ์

แหล่งข้อมูล จากนั้นตัวกรอง แล้วจึงการแปลงข้อมูล ให้เรียกใช้งานเพื่อดูเฉพาะค่า tenfold ของข้อมูลเข้าที่เป็นเลขคู่

package main

import "fmt"

func numbers(vals ...int) <-chan int {
    out := make(chan int)
    go func() { defer close(out); for _, v := range vals { out <- v } }()
    return out
}

func evens(in <-chan int) <-chan int {
    out := make(chan int)
    go func() { defer close(out); for v := range in { if v%2 == 0 { out <- v } } }()
    return out
}

func tenfold(in <-chan int) <-chan int {
    out := make(chan int)
    go func() { defer close(out); for v := range in { out <- v * 10 } }()
    return out
}

func main() {
    for v := range tenfold(evens(numbers(1, 2, 3, 4, 5, 6))) {
        fmt.Println(v)
    }
}

การส่งข้อมูลต่อเนื่อง ไม่ใช่การแบ่งเป็นชุด

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

ไปป์ไลน์ทำงานเมื่อมีการเรียกใช้

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

การเพิ่มการทำงานพร้อมกัน

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

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

ทดสอบความเข้าใจของคุณเกี่ยวกับไปป์ไลน์

สรุปทบทวน

คุณได้เรียนรู้ stage ของไปป์ไลน์ดังนี้:

แต่ละ stage รับข้อมูลเข้าอย่างเดียวและส่งคืนผลลัพธ์ออกอย่างเดียว
defer close(out) ส่งต่อสัญญาณสิ้นสุดกระแสข้อมูล
ต่อ stage ด้วยการซ้อนการเรียกฟังก์ชัน
ไปป์ไลน์ส่งข้อมูลแบบทำงานเมื่อมีการเรียกใช้ พร้อมแรงดันย้อนกลับ

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

บทเรียน “ขั้นตอนของกระบวนการประมวลผล” ฟรีหรือไม่

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

คุณจะเรียนรู้อะไรในบทเรียน “ขั้นตอนของกระบวนการประมวลผล”

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

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

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

บทเรียน “ขั้นตอนของกระบวนการประมวลผล” ใช้เวลานานแค่ไหน

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

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

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

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

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