Go Academy · บทเรียน

ตัวจับเวลาและตัวนับเวลา

กำหนดเวลาและทำงานซ้ำ

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

การหยุดชั่วคราวด้วย Sleep

เครื่องมือกำหนดเวลาที่เรียบง่ายที่สุดคือ time.Sleep(d) ซึ่งหยุดโกโรทีนปัจจุบันไว้เป็นระยะเวลาหนึ่ง

package main

import (
    "fmt"
    "time"
)

func main() {
    fmt.Println("start")
    time.Sleep(10 * time.Millisecond)
    fmt.Println("done")
}

ตัวจับเวลาคืออะไร

time.Timer จะทำงาน ครั้งเดียว หลังจากหน่วงเวลา โดยส่งเวลาปัจจุบันผ่านช่อง C เมื่อหมดเวลา

package main

import (
    "fmt"
    "time"
)

func main() {
    t := time.NewTimer(10 * time.Millisecond)
    <-t.C
    fmt.Println("timer fired")
}

ทางลัด time.After

time.After(d) คืนค่าช่องทางที่ส่งค่าหนึ่งค่าเมื่อพ้นช่วงเวลาหน่วง เป็นตัวจับเวลาแบบทำงานครั้งเดียวที่สะดวกและไม่ต้องใช้ตัวแปร

package main

import (
    "fmt"
    "time"
)

func main() {
    <-time.After(10 * time.Millisecond)
    fmt.Println("elapsed")
}

การหยุดตัวจับเวลา

timer.Stop() ยกเลิกตัวจับเวลาก่อนที่จะทำงาน โดยคืนค่า true หากหยุดตัวจับเวลาได้ทันเวลา

package main

import (
    "fmt"
    "time"
)

func main() {
    t := time.NewTimer(time.Hour)
    stopped := t.Stop()
    fmt.Println("stopped:", stopped)
}

ตัวส่งสัญญาณตามช่วงเวลาคืออะไร

time.Ticker จะทำงาน ซ้ำ ๆ ตามช่วงเวลาคงที่ และส่งค่าผ่านช่อง C ในแต่ละครั้ง

ใช้สำหรับงานที่ทำเป็นระยะ เช่น การสำรวจข้อมูลหรือเฟรมภาพเคลื่อนไหว

package main

import (
    "fmt"
    "time"
)

func main() {
    ticker := time.NewTicker(5 * time.Millisecond)
    <-ticker.C
    fmt.Println("tick")
    ticker.Stop()
}

การนับสัญญาณ

วนซ้ำผ่านช่องของตัวส่งสัญญาณเพื่อดำเนินการในแต่ละช่วงเวลา แล้วหยุดเมื่อได้รับสัญญาณครบตามจำนวน

package main

import (
    "fmt"
    "time"
)

func main() {
    ticker := time.NewTicker(5 * time.Millisecond)
    for i := 1; i <= 3; i++ {
        <-ticker.C
        fmt.Println("tick", i)
    }
    ticker.Stop()
}

หยุดตัวส่งสัญญาณเสมอ

ต่างจากตัวจับเวลา ตัวส่งสัญญาณจะทำงานต่อไปจนกว่าคุณจะเรียกใช้ Stop() หากลืมหยุด จะทำให้ทรัพยากรรั่วไหล

package main

import (
    "fmt"
    "time"
)

func main() {
    ticker := time.NewTicker(5 * time.Millisecond)
    defer ticker.Stop()
    <-ticker.C
    fmt.Println("one tick, will stop on return")
}

ความสะดวกของ time.Tick

time.Tick(d) คืนค่าช่องของตัวส่งสัญญาณโดยตรง ใช้งานง่ายแต่ไม่สามารถหยุดได้ จึงควรใช้เฉพาะกับงานที่มีอายุการทำงานเท่ากับทั้งโปรแกรมเท่านั้น

package main

import (
    "fmt"
    "time"
)

func main() {
    c := time.Tick(5 * time.Millisecond)
    <-c
    fmt.Println("ticked")
}

การหมดเวลาด้วย select

รวมช่องทางงานเข้ากับ time.After ใน select เพื่อใช้กำหนดการหมดเวลา

package main

import (
    "fmt"
    "time"
)

func main() {
    done := make(chan bool)
    go func() { done <- true }()
    select {
    case <-done:
        fmt.Println("work finished")
    case <-time.After(time.Second):
        fmt.Println("timed out")
    }
}

AfterFunc เรียกใช้ฟังก์ชันเรียกกลับ

time.AfterFunc(d, f) เรียกใช้ฟังก์ชัน f ในโกโรทีนของตัวเองหลังจากหน่วงเวลา โดยที่คุณไม่ต้องอ่านค่าจากช่องทาง

package main

import (
    "fmt"
    "time"
)

func main() {
    done := make(chan bool)
    time.AfterFunc(10*time.Millisecond, func() {
        fmt.Println("callback ran")
        done <- true
    })
    <-done
}

ตัวจับเวลาเทียบกับตัวส่งสัญญาณตามช่วงเวลา

เลือกใช้ตามจำนวนครั้งที่ต้องการให้ทำงาน:

ตัวจับเวลา: ทำงานครั้งเดียวหลังจากหน่วงเวลา
ตัวส่งสัญญาณตามช่วงเวลา: ทำงานซ้ำไปเรื่อย ๆ ตามช่วงเวลา
หยุดทั้งสองอย่างเมื่อทำงานเสร็จ เพื่อคืนทรัพยากร

package main

import (
    "fmt"
    "time"
)

func main() {
    <-time.After(5 * time.Millisecond)
    fmt.Println("one-shot complete")
}

ตรวจสอบความเข้าใจ

ชนิดใดทำงานซ้ำ ๆ ตามช่วงเวลาคงที่

สรุปทบทวน: ตัวจับเวลาและตัวส่งสัญญาณตามช่วงเวลา

คุณได้เรียนรู้การกำหนดเวลาทำงานแล้ว:

Sleep หยุดชั่วคราว ส่วน Timer และ time.After ทำงานครั้งเดียว
Ticker และ time.Tick ทำงานซ้ำ ๆ
ใช้ Stop() เพื่อเก็บกวาดทรัพยากร และใช้ร่วมกับ select เพื่อกำหนดการหมดเวลา

package main

import (
    "fmt"
    "time"
)

func main() {
    ticker := time.NewTicker(5 * time.Millisecond)
    defer ticker.Stop()
    for i := 0; i < 2; i++ {
        <-ticker.C
        fmt.Println("beat")
    }
}

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

บทเรียน “ตัวจับเวลาและตัวนับเวลา” ฟรีหรือไม่

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