golang menutup Ctrip

Dalam beberapa tahun kebelakangan ini, bahasa Go telah menjadi bahasa pengaturcaraan yang sangat popular dalam bidang konkurensi tinggi dan aplikasi data berskala besar. Antaranya, dalam bahasa Go, coroutine (juga dipanggil rutin Go) ialah konsep yang sangat penting, yang sangat membantu untuk pengaturcaraan serentak.

Coroutine boleh dianggap sebagai benang ringan tidak memerlukan penjadualan thread peringkat kernel oleh sistem pengendalian, tetapi dijadualkan oleh persekitaran masa jalan bahasa Go. Oleh itu, penciptaan dan pemusnahan coroutine adalah agak pantas dan boleh menyokong pemprosesan serentak yang sangat cekap.

Walau bagaimanapun, dalam aplikasi sebenar, kami selalunya perlu menutup coroutine yang sedang berjalan, yang akan melibatkan beberapa masalah Artikel ini akan menganalisis masalah ini secara terperinci.

Masalah menutup coroutine

Sebenarnya bukan mudah untuk menutup coroutine. Ini kerana, dalam bahasa Go, coroutine dijadualkan mengikut persekitaran masa jalan bahasa Go, dan susunan pelaksanaan serta status berjalannya ditentukan oleh persekitaran masa jalan itu sendiri. Jika anda ingin menutup coroutine, sukar untuk menghentikan secara langsung pelaksanaannya melalui kuasa luar.

Persekitaran masa jalan bahasa Go menyediakan fungsi runtime.Goexit() untuk menghentikan pelaksanaan coroutine semasa, tetapi ia hanya boleh menghentikan coroutine semasa dan tidak boleh menghentikan coroutine lain.

Jadi, bagaimana kita menutup coroutine yang sedang berjalan? Pada masa ini, kita perlu mempertimbangkan isu-isu berikut:

1. Cara memberitahu coroutine untuk berhenti sendiri

Dalam sesetengah kes, kita boleh Bendera ditetapkan dalam coroutine untuk menunjukkan sama ada ia perlu berhenti, dan kemudian dalam keadaan tertentu, kami boleh memberitahu coroutine untuk berhenti sendiri dengan menetapkan bendera ini.

Walau bagaimanapun, pendekatan ini hanya berfungsi untuk coroutine yang boleh berhenti sendiri. Bagi coroutine yang tidak dapat menghentikan diri mereka, kita perlu menggunakan kaedah lain untuk menutupnya.

2. Bagaimana menunggu coroutine selesai

Jika kita tidak boleh menghentikan coroutine sendiri, maka kita perlu menunggu sehingga ia selesai kerjanya sebelum menutupnya. Pada masa ini, kami memerlukan cara yang boleh dipercayai untuk menunggu coroutine selesai.

Dalam bahasa Go, kita boleh menunggu selesainya coroutine dengan menggunakan WaitGroup. WaitGroup ialah primitif serentak dalam bahasa Go, yang boleh digunakan untuk menunggu selesainya kumpulan coroutine.

3. Cara menutup dengan selamat

Apabila menutup coroutine, kita perlu memastikan keselamatan penutupan. Ini kerana jika coroutine tidak dibersihkan sepenuhnya sebelum ditutup, ia boleh menyebabkan kebocoran memori atau akibat lain yang tidak diingini.

Dalam bahasa Go, kita boleh menggunakan pernyataan defer untuk melaksanakan kerja pembersihan dan memastikan coroutine menyelesaikan semua kerja pembersihan yang diperlukan sebelum menutup.

Pelaksanaan penutupan coroutine dalam bahasa Go

Setelah memahami masalah penutupan coroutine, mari kita lihat cara menutup coroutine dalam bahasa Go. Berikut ialah beberapa kaedah:

Kaedah 1: Gunakan pemberitahuan isyarat

Dalam bahasa Go, kita boleh menggunakan channel untuk melaksanakan komunikasi antara coroutine. Kita boleh menghentikan coroutine sendiri dengan menghantar isyarat kepada channel tertentu.

Berikut ialah contoh kod:

package main

import (
    "fmt"
    "time"
)

func worker(done chan bool) {
    fmt.Println("Worker: started")
    time.Sleep(time.Second)
    fmt.Println("Worker: done")
    done <- true
}

func main() {
    done := make(chan bool, 1)
    go worker(done)

    <-done
    fmt.Println("Main: done")
}

Dalam kod sampel di atas, kami mula-mula mentakrifkan coroutine bernama worker, yang akan melakukan beberapa kerja dan menghantarnya ke doneSaluran menghantar isyarat. Dalam fungsi main, kami mencipta saluran bernama done dan menghantarnya ke coroutine.

Semasa menunggu saluran done, fungsi main akan disekat sehingga worker coroutine selesai dan menghantar isyarat. Sebaik sahaja isyarat diterima, fungsi main akan terus melaksanakan dan mengeluarkan Main: done.

Kaedah 2: Gunakan context.Context

Dalam bahasa Go, kita boleh menggunakan pakej context untuk mengurus konteks coroutine. Dengan menggunakan context.Context, kita boleh memulakan coroutine dalam konteks tertentu dan membatalkan konteks apabila kita perlu menghentikan coroutine, dengan itu menghentikan pelaksanaan coroutine.

Berikut ialah contoh kod:

package main

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

func worker(ctx context.Context) {
    fmt.Println("Worker: started")
    for {
        select {
        case <-ctx.Done():
            fmt.Println("Worker: done")
            return
        default:
            fmt.Println("Worker: working")
            time.Sleep(time.Second)
        }
    }
}

func main() {
    ctx, cancel := context.WithCancel(context.Background())
    go worker(ctx)

    time.Sleep(3 * time.Second)
    cancel()

    fmt.Println("Main: done")
}

Dalam kod sampel di atas, kami mula-mula mentakrifkan coroutine bernama worker dan dalam gelung utamanya kami menggunakan pernyataan select untuk mendengar dua saluran: ctx.Done() dan default saluran. Jika saluran ctx.Done() menerima isyarat, coroutine akan keluar.

Dalam fungsi main, kami mula-mula mencipta context.Context dan menambahkannya pada konteks menggunakan fungsi context.WithCancel. Kemudian, kami menyampaikan konteks ini kepada worker coroutine. Selepas melaksanakan untuk tempoh masa, kami memanggil fungsi cancel untuk membatalkan konteks, dengan itu menghentikan pelaksanaan worker coroutine.

Ringkasan

Melalui dua kaedah di atas, kita boleh menutup coroutine dalam bahasa Go dengan selamat. Apabila menutup coroutine, kita perlu mempertimbangkan sama ada coroutine boleh berhenti sendiri, cara menunggu coroutine selesai, dan cara menutup coroutine dengan selamat. Dengan menggunakan primitif serentak bahasa Go dengan betul seperti channel, WaitGroup dan context, kami boleh mencapai operasi penutupan coroutine yang cekap, selamat dan boleh dipercayai.

Atas ialah kandungan terperinci golang menutup Ctrip. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!