Go Academy · Pelajaran

Penghentian Job yang Mulus

Hentikan job dengan rapi

Penghentian Job yang Mulus adalah pelajaran Go Academy gratis di CoddyKit. Ini adalah pelajaran 4 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.

Menghentikan Pekerjaan dengan Rapi

Penjadwal yang dihentikan di tengah pekerjaan dapat merusak data atau meninggalkan pekerjaan yang belum selesai. Penghentian teratur berarti: berhenti menerima eksekusi baru, membiarkan pekerjaan yang sedang berjalan selesai hingga batas waktu, lalu keluar.

Mendengarkan Sinyal

Tangkap sinyal OS seperti SIGINT (Ctrl+C) dan SIGTERM (penghentian oleh pengatur orkestrasi) agar Anda dapat melakukan penghentian dengan sengaja.

sig := make(chan os.Signal, 1)
signal.Notify(sig, syscall.SIGINT, syscall.SIGTERM)
<-sig
fmt.Println("shutting down")

signal.NotifyContext

Go 1.16+ menyediakan pembantu ringkas yang membatalkan konteks ketika sinyal tiba.

ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt)
defer stop()
<-ctx.Done()

Menghentikan Penjadwal

Dengan robfig/cron, c.Stop() mengembalikan konteks yang selesai setelah semua pekerjaan yang sedang berjalan selesai. Tunggulah konteks tersebut sampai semua pekerjaan selesai.

ctx := c.Stop()        // stops scheduling, returns ctx
<-ctx.Done()            // wait for running jobs
fmt.Println("all jobs finished")

Meneruskan Pembatalan ke Pekerjaan

Teruskan konteks ke setiap pekerjaan agar pekerjaan yang berjalan lama dapat dibatalkan segera ketika penghentian dimulai.

func job(ctx context.Context) {
    select {
    case <-time.After(time.Hour):
    case <-ctx.Done():
        return // bail out early
    }
}

Membatasi Waktu Tunggu

Jangan menunggu selamanya untuk pekerjaan yang macet. Gunakan konteks batas waktu agar penghentian tetap selesai meskipun suatu pekerjaan macet.

shutCtx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
defer cancel()

WaitGroups untuk Penjadwal Kustom

Jika Anda membuat penjadwal sendiri dengan gorutin, lacak gorutin tersebut menggunakan sync.WaitGroup dan Wait() selama penghentian.

var wg sync.WaitGroup
wg.Add(1)
go func() { defer wg.Done(); doWork() }()
// shutdown:
wg.Wait()

Hindari Memulai Pekerjaan Baru

Setelah penghentian dimulai, penghitung detak/cron harus berhenti memicu tindakan. Menutup saluran selesai atau membatalkan konteks memastikan perulangan melihat sinyal tersebut dan berhenti menjadwalkan eksekusi baru.

Idempotensi Membantu

Rancang pekerjaan agar aman dijalankan ulang. Jika suatu pekerjaan dihentikan di tengah jalan dan dicoba lagi setelah dimulai ulang, logika idempoten mencegah efek ganda (email ganda, tagihan ganda).

Pola Lengkap

Jika digabungkan: konteks pemberitahuan saat sinyal diterima, penghentian cron yang mengembalikan konteks untuk menunggu pekerjaan selesai, dan batas waktu yang dibatasi. Inilah kerangka dasar penghentian teratur untuk layanan terjadwal.

Dapat Dijalankan: Penghentian Teratur dengan Konteks

Program mandiri ini menjalankan pekerja berkala dan menghentikannya dengan baik melalui pembatalan konteks, sambil menunggu detak yang sedang berjalan selesai.

package main

import (
    "context"
    "fmt"
    "sync"
    "time"
)

func main() {
    ctx, cancel := context.WithCancel(context.Background())
    var wg sync.WaitGroup
    wg.Add(1)
    go func() {
        defer wg.Done()
        t := time.NewTicker(5 * time.Millisecond)
        defer t.Stop()
        for {
            select {
            case <-t.C:
                fmt.Println("working")
            case <-ctx.Done():
                fmt.Println("stopping cleanly")
                return
            }
        }
    }()
    time.Sleep(17 * time.Millisecond)
    cancel()   // signal shutdown
    wg.Wait()  // wait for worker to finish
    fmt.Println("shutdown complete")
}

Pemeriksaan Singkat

Uji pemahaman Anda tentang penghentian pekerjaan secara teratur.

Ringkasan

Anda telah mempelajari penghentian pekerjaan secara teratur:

Tangkap SIGINT/SIGTERM, idealnya melalui signal.NotifyContext
cron.Stop() mengembalikan konteks yang menunggu semua pekerjaan yang sedang berjalan selesai
Teruskan konteks ke pekerjaan dan batasi waktu tunggu dengan batas waktu
Jadikan pekerjaan idempoten agar percobaan ulang tetap aman

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Penghentian Job yang Mulus” gratis?

Ya — teks lengkap “Penghentian Job yang Mulus” 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 “Penghentian Job yang Mulus”?

Hentikan job dengan rapi 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 4 dari 4.

Berapa lama pelajaran “Penghentian Job yang Mulus” 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