0Pricing
Go Academy · บทเรียน

รูปแบบกลุ่มผู้ปฏิบัติงาน

จำกัดการทำงานพร้อมกัน

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

กลุ่ม worker คืออะไร

กลุ่ม worker จะเปิดใช้โกโรทีนจำนวนคงที่ ซึ่งทั้งหมดดึงงานจากช่องสัญญาณร่วมกัน แทนที่จะสร้างโกโรทีนหนึ่งตัวต่องานหนึ่งรายการ คุณจะสร้าง worker จำนวน N ตัวแล้วป้อนงานให้พวกมัน

  • จำกัดจำนวนการดำเนินการที่ทำพร้อมกัน
  • นำโกโรทีนกลับมาใช้ใหม่แทนการสร้างหลายพันตัว
  • ปกป้องทรัพยากรร่วม เช่น ฐานข้อมูลหรือส่วนติดต่อบริการ

เหตุใดจึงต้องจำกัดการทำงานพร้อมกัน

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

หากคุณมี URL 10000 รายการที่ต้องดึงข้อมูล คุณคงไม่ต้องการคำขอ HTTP พร้อมกัน 10000 รายการ กลุ่ม worker จำนวน 20 ตัวช่วยให้การทำงานอยู่ในระดับเหมาะสม

ช่องงาน

งานจะไหลเข้าสู่ช่อง jobs worker แต่ละตัวอ่านค่าจากช่องนี้ในลูป for range เมื่อช่องปิด ลูปจะจบลงและ worker จะออกจากการทำงาน

jobs := make(chan int, 100)
for j := 1; j <= 5; j++ {
    jobs <- j
}
close(jobs)

worker หนึ่งตัว

worker เป็นเพียงฟังก์ชันที่วนอ่านช่องงาน โดยจะประมวลผลแต่ละงานแล้วเขียนผลลัพธ์ลงในช่องผลลัพธ์

func worker(id int, jobs <-chan int, results chan<- int) {
    for j := range jobs {
        results <- j * 2
    }
}

เริ่ม worker หลายตัว

เปิดใช้กลุ่ม worker ด้วยลูปง่าย ๆ ในแต่ละรอบจะเริ่มโกโรทีนหนึ่งตัวที่เรียกใช้ฟังก์ชัน worker เดียวกัน ทั้งหมดใช้ช่องงานและช่องผลลัพธ์ร่วมกัน

for w := 1; w <= 3; w++ {
    go worker(w, jobs, results)
}

ชนิดช่องสัญญาณแบบกำหนดทิศทาง

สังเกต <-chan int (รับอย่างเดียว) และ chan<- int (ส่งอย่างเดียว) ในลายเซ็นของ worker ชนิดที่กำหนดทิศทางเหล่านี้ช่วยให้คอมไพเลอร์ป้องกันไม่ให้ worker เผลอส่งข้อมูลเข้าไปในช่องงานหรืออ่านข้อมูลจากช่องผลลัพธ์

รวบรวมผลลัพธ์

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

sum := 0
for a := 1; a <= 5; a++ {
    sum += <-results
}
fmt.Println("total:", sum)

กลุ่ม worker ที่ทำงานได้ครบถ้วน

นี่คือรูปแบบทั้งหมดในโปรแกรมเดียว โดยมี worker สามตัวคูณตัวเลขห้าตัวด้วยสอง ลองเรียกใช้แล้วสังเกตผลรวม

package main

import "fmt"

func worker(id int, jobs <-chan int, results chan<- int) {
    for j := range jobs {
        results <- j * 2
    }
}

func main() {
    jobs := make(chan int, 5)
    results := make(chan int, 5)
    for w := 1; w <= 3; w++ {
        go worker(w, jobs, results)
    }
    for j := 1; j <= 5; j++ {
        jobs <- j
    }
    close(jobs)
    total := 0
    for a := 1; a <= 5; a++ {
        total += <-results
    }
    fmt.Println("total:", total)
}

มีบัฟเฟอร์กับไม่มีบัฟเฟอร์

ช่องงานที่มีบัฟเฟอร์ช่วยให้ตัวผลิตงานจัดคิวงานได้โดยไม่ถูกบล็อกจนกว่าบัฟเฟอร์จะเต็ม ส่วนช่องที่ไม่มีบัฟเฟอร์จะบังคับให้ส่งต่องานทันที โดยการส่งจะถูกบล็อกจนกว่า worker จะพร้อม การใช้บัฟเฟอร์ช่วยลดความผันผวนของตัวผลิตงานที่ส่งงานเป็นช่วง ๆ

การเลือกขนาดกลุ่ม worker

สำหรับงานที่ใช้ CPU เป็นหลัก ให้กำหนดขนาดกลุ่มใกล้เคียงกับ runtime.NumCPU() สำหรับงานที่ใช้ IO เป็นหลัก (เครือข่าย ดิสก์) คุณสามารถใช้จำนวนที่สูงกว่านี้มากได้ เนื่องจาก worker ใช้เวลารอ ไม่ได้ใช้เวลาคำนวณ

package main

import (
    "fmt"
    "runtime"
)

func main() {
    fmt.Println("CPUs:", runtime.NumCPU())
}

หลีกเลี่ยงโกโรทีนรั่วไหล

หากคุณลืม close(jobs) worker จะถูกบล็อกตลอดไปบนช่องว่างและเกิดการรั่วไหล ให้ปิดช่องงานเสมอเมื่อส่งงานทั้งหมดแล้ว เพื่อให้ลูป for range สิ้นสุดลง

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

ทดสอบความเข้าใจของคุณเกี่ยวกับพูลเวิร์กเกอร์

สรุปทบทวน

คุณได้เรียนรู้รูปแบบพูลเวิร์กเกอร์ดังนี้:

  • สร้างเวิร์กเกอร์จำนวนคงที่เพื่ออ่านงานจากแชนเนลงานร่วมกัน
  • ใช้ประเภทแชนเนลแบบกำหนดทิศทางเพื่อความปลอดภัย
  • ปิดแชนเนลงานเพื่อยุติเวิร์กเกอร์
  • รวบรวมผลลัพธ์เพื่อประสานการทำงานให้เสร็จสิ้น
  • กำหนดขนาดพูลตามประเภทภาระงาน (CPU เทียบกับ IO)

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

บทเรียน “รูปแบบกลุ่มผู้ปฏิบัติงาน” ฟรีหรือไม่

ใช่ — ข้อความเต็มของ “รูปแบบกลุ่มผู้ปฏิบัติงาน” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ 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 ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ

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

  1. รูปแบบกลุ่มผู้ปฏิบัติงาน
  2. Fan-Out Fan-In
  3. ขั้นตอนของกระบวนการประมวลผล
  4. การปิดระบบอย่างราบรื่น
← กลับไปที่ Go Academy