고루틴

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

การ การ การ งาน งาน goroutine ใน ภาษา ภาษา ภาษา อนุญาติ ให้ ให้ ทำ ทำ งาน หลาย หลาย ๆ ๆ งาน ใน ใน เวลา เดียว กัน (coroutine) งาน เหล่า ๆ นั้น นั้น นั้น (루틴) สามารถ ทำ ทำ งาน ใน ใน กัน กัน goroutine นั้น แบ่ง แบ่ง พื้นที่ พื้นที่ กัน กัน กับ อื่น อื่น ทำ ให้ มัน แตกต่าง แตกต่าง จาก แต่ แต่ แต่ แต่ แต่ แต่ แต่ แต่ แต่ แต่ แต่ แต่ แต่ นั้น นั้น นั้น นั้น นั้น นั้น ไม่ ไม่ ไม่ ไม่ ไม่ ไม่ แบ่ง แบ่ง แบ่ง แบ่ง แบ่ง แบ่ง ไม่ ไร ไร ไร ไร ไร อย่าง แต่ แต่ แต่. เรา เรา เรา ส่ง สามารถ แปร เข้า ไป ไป อีก อีก อีก 코 루틴 ได้ ได้ โค็ด แต่ แต่ อาจ จะ ทำ ให้ ให้ มัน เกิด การ ทำ งาน คาดเดา คาดเดา ไม่ ได้ ได้ ได้ ได้

ลองมาดูการทำงานของ ฟังก์ชัน 안녕하세요

func hello() {
    fmt.Println("hello world")
}

ทีนี้เราจะลองเรียกใช้ฟังก์ชันนี้

func main() {
    fmt.Println("hello")

    // รูปแบบการเรียกใช้ฟังก์ชัน hello แบบ coroutine
    go hello()

    fmt.Println("end")
}

จะ จะ จะ ผลลัพท์ เห็น ไม่ ไม่ มี การ แสดง ข้อ ความ ความ hello world ออก มา ว่า ว่า ฟังก์ชัน ฟังก์ชัน ไม่ ไม่ ไม่ สน ว่า ฟังก์ชัน ฟังก์ชัน hello นั้น จะ ทำ ทำ งานนาน งานนาน แค่ แค่ ไหน พอ พอ มัน เรียก ใช้ งาน ฟังก์ชัน แล้ว ฟังก์ชัน ฟังก์ชัน ก็ ก็ งาน งาน ต่อ ต่อ ต่อ ต่อ ต่อ ต่อ ต่อ ต่อ ต่อ ทำ ฟังก์ชัน ฟังก์ชัน ฟังก์ชัน

มาลองใช้ 동시 루틴

ลอง ลอง นาการ นาการ จิต เรา จะ คำ นวน ค่า ค่า ต่าง ต่าง ๆ ๆ ๆ 2 ครั้ง ครั้ง แรก แรก เรา เรา จะ หา ผล ผล รวม ตัว เลข จาก 1-10 หลัง จาก นั้น นั้น หา ผล ผล รวม ตัว เลข 1-100 เพื่อ ไม่ ให้ เป็น การ เสีย เสีย เวลา เรา ทำ ทำ การ คำ นวน ของ ของ ของ ของ ของ เพื่อ ไม่ ไม่ ไม่ ไม่ ไม่ ไม่ นี้ไปพร้อมๆกันด้วย 코루틴

func main() {
    var s1 int
    go func() {
        s1 = sum(1, 100)
    }()

    log.Println(s1)
}

func sum(from, to int) int {
    res := 0
    for i := from; i <= to; i++ {
        res += i
    }

    return res
}

ตัว ตัว ตัว ตัว ตัว ตัว แปร แสดง มา เป็น 0 เนื่อง เนื่อง จาก ใน ใน เรียก ฟังก์ชัน ฟังก์ชัน ฟังก์ชัน ใน ใน 메인 ยัง ยัง ทำ งาน ไม่ เสร็จ และ ตัว แปร แปร แปร แปร ยัง คง เป็น 0

ทีนี้ลองเรียกเป็นแบบ

func main() {
    var s1 int
    go func() {
        s1 = sum(1, 100)
    }()

    // ลองเพิ่ม statement ไปเพื่อรอให้ฟังก์ชัน sum ทำงานเสร็จ
    time.Sleep(time.Second)

    log.Println(s1)
}

func sum(from, to int) int {
    res := 0
    for i := from; i <= to; i++ {
        res += i
    }

    return res
}

대기 그룹

Coroutine มาก มาก กว่า กว่า 1 ตัว ขึ้น ขึ้น ไป ไป เพื่อ ที่ ที่ จะ ควบคุม ควบคุม การ ทำ งาน ของ ของ ของ เป็น ไป ไป ลำดับ ลำดับ ที่ ที่ เรา เรา ต้องการ เรา ต้อง ใช้ waitgroup {} ช่วย

package main 
import "sync" 
func main() {
    // สร้าง pointer ชี้ไปที่ wait group
  wg := &sync.WaitGroup{}

    // เพิ่มคำสั่ง asynchronous เข้าไป เพื่อบอกให้รู้ว่าให้รอ goroutine 1 ตัวด้านล่างทำงานให้เสร็จก่อนไปทำงานอื่น
  wg.Add(1)
  go func() {
        // wait routine
        ...
        .
        .
        wg.Done() // บอกตัว wait group ว่าใน go routine นี้ทำงานเสร็จแล้ว
    }()
  wg.Wait()

    // หลังจากทำงาน go routine ด้านบนเสร็จแล้วก็ทำอันด้านล่างต่อ
  ………….
  ………….
}

หลัง หลัง หลัง ที่ จาก ได้ ปรับ ปรับ ใช้ 대기 그룹 กับ กับ การ คำ นวน นวน ผล รวม ตั้ง แต่ 1-10 และ 1-100

package main

import (
    "log"
    "sync"
)

func main() {
    s1 := 0
    s2 := 0
    wg := &sync.WaitGroup{}

    // ถ้าเราใส่แค่ 1 จะเกิด panic ทันทีเพราะ wg ถูกใช้งาน 2 ครั้ง
    wg.Add(2)
    go sum(1, 100, wg, &s1)
    go sum(1, 200, wg, &s2)
    wg.Wait()

    log.Println(s1, s2)
}

func sum(from, to int, wg *sync.WaitGroup, res *int) {
    *res = 0
    for i := from; i <= to; i++ {
        *res += i
    }

    wg.Done()
}

...위프 ...