Go Academy · Pelajaran

Penghentian yang Mulus

Hentikan worker dengan rapi

Penghentian 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.

Mengapa Penghentian Tertib

Goroutine yang berjalan lama harus diberi tahu kapan harus berhenti. Penghentian tertib memungkinkan worker menyelesaikan pekerjaan saat ini, melepaskan sumber daya, dan keluar tanpa kebocoran atau kehilangan data.

Tidak ada goroutine yang bocor
Tidak ada penulisan yang belum selesai
Proses keluar dengan bersih

Pola Kanal done

Pendekatan klasik adalah kanal done. Menutupnya menyiarkan sinyal berhenti ke semua goroutine yang mendengarkannya, karena kanal yang tertutup segera mengembalikan hasil saat dibaca.

done := make(chan struct{})
// ... later
close(done)

select untuk Sinyal Stop

Worker menggunakan select untuk memproses pekerjaan atau mendeteksi kanal done. Ketika done ditutup, kasus tersebut dijalankan dan worker keluar.

for {
    select {
    case <-done:
        return
    case j := <-jobs:
        process(j)
    }
}

context.Context

Alat modern yang lazim digunakan adalah context. context.WithCancel memberi Anda konteks dan fungsi pembatalan. Memanggil cancel menutup kanal Done milik konteks.

ctx, cancel := context.WithCancel(context.Background())
defer cancel()

Mendengarkan pada ctx.Done()

Worker melakukan select pada ctx.Done(). Ketika cancel dipanggil atau tenggat waktu terlewati, kanal tersebut ditutup dan worker keluar.

select {
case <-ctx.Done():
    return ctx.Err()
case j := <-jobs:
    process(j)
}

Menunggu Worker

Mengirim sinyal berhenti saja tidak cukup; Anda harus menunggu sampai worker benar-benar selesai. sync.WaitGroup melacak worker sehingga main dapat terblokir sampai hitungannya mencapai nol.

var wg sync.WaitGroup
wg.Add(1)
go func() {
    defer wg.Done()
    runWorker(ctx)
}()
// ... later
cancel()
wg.Wait()

Batas Waktu dengan context

context.WithTimeout membatalkan secara otomatis setelah durasi tertentu. Hal ini membatasi berapa lama penghentian dapat berlangsung sebelum Anda memaksa proses keluar.

ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
defer cancel()

Penghentian Tertib Lengkap

Program ini menjalankan dua worker, membatalkan konteks, lalu menunggu keduanya keluar dengan bersih sebelum mencetak done.

package main

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

func worker(ctx context.Context, id int, wg *sync.WaitGroup) {
    defer wg.Done()
    for {
        select {
        case <-ctx.Done():
            fmt.Printf("worker %d stopping\n", id)
            return
        case <-time.After(50 * time.Millisecond):
        }
    }
}

func main() {
    ctx, cancel := context.WithCancel(context.Background())
    var wg sync.WaitGroup
    for i := 1; i <= 2; i++ {
        wg.Add(1)
        go worker(ctx, i, &wg)
    }
    time.Sleep(120 * time.Millisecond)
    cancel()
    wg.Wait()
    fmt.Println("all workers stopped")
}

Menyelesaikan Pekerjaan yang Sedang Berjalan

Saat penghentian, Anda sering ingin worker menyelesaikan pekerjaan yang sudah dimulainya. Baca pekerjaan yang tersisa dalam perulangan terakhir, atau berhenti menerima pekerjaan baru sambil membiarkan pekerjaan yang sedang berlangsung selesai.

Menangkap Sinyal OS

Di server nyata, signal.NotifyContext mengaitkan pembatalan dengan SIGINT dan SIGTERM. Menekan Ctrl+C kemudian memicu alur penghentian tertib yang sama seperti pembatalan manual.

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

Jangan Pernah Lupa cancel()

Selalu gunakan defer cancel(), bahkan saat menggunakan WithTimeout. Jika tidak memanggil cancel, goroutine internal dan pewaktu konteks akan bocor sampai tenggat waktu terlewati.

Pemeriksaan Singkat

Uji pemahaman Anda tentang penghentian.

Ringkasan

Anda telah mempelajari penghentian tertib:

Gunakan context.WithCancel atau kanal done untuk memberi sinyal berhenti
Worker melakukan select pada ctx.Done()
WaitGroup memastikan semua worker benar-benar keluar
Kaitkan pembatalan dengan sinyal OS untuk server nyata
Selalu gunakan defer cancel()

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Penghentian yang Mulus” gratis?

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

Hentikan worker 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 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