Go Academy · Pelajaran

Timer dan Ticker

Jadwalkan dan ulangi pekerjaan

Pelajaran 3 dari 413 langkah

Timer dan Ticker adalah pelajaran Go Academy gratis di CoddyKit. Ini adalah pelajaran 3 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar Go Academy, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus Go Academy mencakup 4 pelajaran total.

Menjeda dengan Sleep

Alat penjadwalan paling sederhana adalah time.Sleep(d), yang menjeda goroutine saat ini selama suatu durasi.

package main

import (
    "fmt"
    "time"
)

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

Apa Itu Timer?

time.Timer terpicu sekali setelah jeda. Saat waktunya habis, objek tersebut mengirimkan waktu saat ini melalui saluran C.

package main

import (
    "fmt"
    "time"
)

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

Pintasan time.After

time.After(d) mengembalikan saluran yang mengirimkan satu nilai setelah jeda. Ini adalah pewaktu sekali jalan yang praktis tanpa variabel.

package main

import (
    "fmt"
    "time"
)

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

Menghentikan Timer

timer.Stop() membatalkan timer sebelum terpicu. Fungsi tersebut mengembalikan true jika timer berhasil dihentikan tepat waktu.

package main

import (
    "fmt"
    "time"
)

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

Apa Itu Ticker?

time.Ticker terpicu secara berulang pada interval tetap dan mengirimkan nilai melalui saluran C setiap kali terpicu.

Gunakan ini untuk pekerjaan berkala seperti pengambilan data berkala atau bingkai animasi.

package main

import (
    "fmt"
    "time"
)

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

Menghitung Tick

Lakukan perulangan pada saluran ticker untuk menjalankan tindakan di setiap interval, lalu hentikan setelah jumlah tick yang cukup.

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()
}

Selalu Hentikan Ticker

Berbeda dengan timer, ticker terus berjalan sampai Anda memanggil Stop(). Jika lupa menghentikannya, sumber daya akan bocor.

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")
}

Kemudahan time.Tick

time.Tick(d) langsung mengembalikan saluran ticker. Cara ini sederhana, tetapi ticker tidak dapat dihentikan, jadi gunakan hanya selama seluruh masa hidup program.

package main

import (
    "fmt"
    "time"
)

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

Batas Waktu dengan select

Gabungkan saluran kerja dengan time.After dalam select untuk menerapkan batas waktu.

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 Menjalankan Fungsi Panggilan Balik

time.AfterFunc(d, f) menjalankan fungsi f dalam goroutine-nya sendiri setelah jeda, tanpa Anda perlu membaca saluran.

package main

import (
    "fmt"
    "time"
)

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

Timer atau Ticker

Pilih berdasarkan pengulangan:

Timer: terpicu sekali setelah jeda.
Ticker: terpicu berulang kali pada suatu interval.
Hentikan keduanya setelah selesai untuk membebaskan sumber daya.

package main

import (
    "fmt"
    "time"
)

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

Pemeriksaan Singkat

Jenis apa yang terpicu berulang kali pada interval tetap?

Jawab di pelajaran interaktif

Ringkasan: Timer dan Ticker

Anda telah mempelajari cara menjadwalkan pekerjaan:

Sleep menjeda; Timer dan time.After terpicu sekali.
Ticker dan time.Tick terpicu berulang kali.
Gunakan Stop() untuk membersihkan sumber daya; gabungkan dengan select untuk batas waktu.

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")
    }
}

Gratis untuk memulai

Belajar Go dengan tutor AI — gratis

Tulis dan jalankan kode asli di browser kamu, dapatkan bantuan instan dari tutor AI 24/7, dan lanjutkan di mana kamu tinggalkan di web atau aplikasi.

Kursus: 51
Pelajaran: 203

Mulai belajar gratis Lihat kursus lengkapnya

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Timer dan Ticker” gratis?

Ya — teks lengkap “Timer dan Ticker” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus Go Academy, upgrade ke CoddyKit PRO. Kursus Go Academy mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “Timer dan Ticker”?

Jadwalkan dan ulangi pekerjaan Kamu berlatih Go Academy dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai Go Academy?

Tidak diperlukan pengalaman sebelumnya. Go Academy di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 3 dari 4.

Berapa lama pelajaran “Timer dan Ticker” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran Go Academy ini?

Ya. Setiap pelajaran Go Academy menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

← Kembali ke Go Academy