Rumah > Artikel > pembangunan bahagian belakang > 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.
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:
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.
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.
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.
Setelah memahami masalah penutupan coroutine, mari kita lihat cara menutup coroutine dalam bahasa Go. Berikut ialah beberapa kaedah:
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 done
Saluran 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
.
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.
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!