Ketahui lebih lanjut tentang penggunaan Go Context

Konteks dalam bahasa Go sangat mudah digunakan Hampir semua program Go menggunakannya untuk menghantar nilai dalam julat permintaan. Ia adalah objek ringan yang membolehkan nilai berskop permintaan dihantar merentasi sempadan API, termasuk isyarat pembatalan, tarikh akhir, ID permintaan, dsb.

Dalam artikel ini, kami akan melihat secara mendalam tentang penggunaan Go Context, memahami kelebihannya dan cara menggunakannya untuk meningkatkan prestasi dan keteguhan aplikasi anda.

Apakah Konteks Go?

Konteks Go ialah perpustakaan standard dalam bahasa Go, digunakan untuk mengurus nilai skop permintaan. Ia menyediakan aplikasi dengan kaedah ringan dan transitif untuk menghantar pembolehubah yang diminta antara goroutine. Ia digunakan terutamanya untuk lulus permintaan pembatalan, had tamat masa, log penjejakan, konteks permintaan, data permintaan, dsb.

Tidak seperti Konteks dalam bahasa pengaturcaraan lain, Go Context mempunyai beberapa sifat yang sangat istimewa:

• Ia selamat untuk benang.
• Nilainya boleh dihantar merentasi goroutin.
• Ia boleh dibatalkan atau tamat masa untuk mengelakkan operasi yang berjalan lama atau tidak dapat dihentikan.
• Ia juga boleh digunakan untuk memisahkan pembatalan permintaan dan pembatalan operasi sebenar.

Senario Penggunaan

Go Context ialah alat yang sangat serba boleh yang boleh digunakan untuk aplikasi dalam senario yang berbeza, beberapa daripadanya termasuk:

1. Aplikasi Web

Aplikasi web ialah salah satu senario penggunaan yang paling biasa. Ia memudahkan untuk mengurus konteks dan metadata khusus permintaan yang diperlukan untuk mengendalikan permintaan HTTP. Semasa pemprosesan permintaan HTTP, Konteks digunakan untuk menghantar ID permintaan, meminta tamat masa, isyarat pembatalan, dsb. merentas pengendali. Sebagai contoh, Konteks digunakan untuk menjejaki keadaan sesi apabila mengendalikan sambungan Websocket.

2. Aplikasi perkhidmatan latar belakang

Aplikasi perkhidmatan latar belakang mungkin perlu merentasi berbilang API untuk menyediakan data kepada sistem luaran Konteks digunakan untuk melengkapkan goroutine dalam aplikasi sedemikian Penamatan yang lebih cekap, pilihan terbaik untuk aplikasi jenis ini. Anda boleh menggunakan fungsi standard Context WithCancel untuk mencapai ini. Jika semua goroutine menggunakan Konteks ini, hanya satu panggilan balik diperlukan untuk menghentikan semua langganan dan membersihkan sumber.

3. Pangkalan Data dan Operasi Fail

Go Context ialah alat yang sesuai untuk mengendalikan fail besar dan operasi DB, kerana operasi ini boleh menjadi sumber dan intensif I/O. Dalam kes ini, Konteks digunakan untuk membatalkan operasi untuk mengelakkan kesilapan dan ralat masa jalan.

4. Aplikasi Teragih

Dalam seni bina perkhidmatan mikro, Konteks digunakan secara meluas untuk menghantar maklumat berskop permintaan daripada API kepada rantaian panggilan setiap perkhidmatan. Dalam kes ini, ID surih disimpan dalam Konteks dan diluluskan apabila menyambung kepada berbilang perkhidmatan. Ini memudahkan pengesanan keseluruhan baris permintaan.

Penggunaan Konteks

Kini setelah kami memahami asas Go Context, kami akan meneroka cara menggunakannya untuk mengurus nilai berskop permintaan.

1. Buat Konteks

Dalam bahasa Go, anda boleh menggunakan context.Background() untuk mencipta konteks peringkat atas yang kosong. Konteks ini bebas secara global dan tidak mengandungi sebarang nilai.

ctx := context.Background()

Anda juga boleh menggunakan fungsi WithValue() untuk mencipta konteks dengan nilai. Sebagai contoh, anda boleh membuat konteks pengendalian permintaan HTTP dengan data permintaan dan had tamat masa.

ctx := context.WithValue(
        context.Background(),
        "requestId",
        uuid.New())

fungsi ctx.Value() menggunakan konteks ini untuk mendapatkan nilai konteks. Dalam contoh di bawah, kita boleh mendapatkan maklumat Konteks dengan meminta pengecam unik.

requestId, ok := ctx.Value("requestId").(value string)

2. Isyarat tamat masa

Menggunakan konteks.WithDeadline atau context.WithTimeout fungsi anda juga boleh menggunakan isyarat tamat masa pada konteks untuk mengelakkan proses berjalan lama. Fungsi

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

cancel() digunakan untuk menandakan status pembatalan Konteks. Konteks akan dibatalkan secara automatik apabila acara tamat masa berlaku.

select {
case <-timeOutCtx.Done():
         if err := timeOutCtx.Err(); err != nil {
                   fmt.Println("Time out due to: ", err)
         }
case <-time.After(5 * time.Second):
       fmt.Println("Hooray! Request done within 5 sec")
}

Dalam contoh ini, kami mencipta Konteks tamat masa 10 saat. Pernyataan pilih menunggu untuk operasi pada dua saluran. Kaedah Done() mengeluarkan isyarat apabila Konteks dibatalkan atau tamat masa.

Kami menghantar pesanan ringkas melalui saluran pemasa dan menunggu selama 5 saat. Memandangkan hujah kedua kepada fungsi context.WithTimeout() kami ialah 10 saat, hanya laluan pertama dalam pernyataan pilih harus dilaksanakan.

3. Konteks boleh dibatalkan

Konteks digunakan semasa proses berjalan lama Ciri isyarat pembatalan boleh digunakan untuk mengelakkan beban yang tidak dijangka pada sistem.

Dalam coretan kod berikut, kami akan menggunakan context.WithCancel() untuk mencipta Konteks dan kemudian gunakan fungsi cancel() untuk menandakan status pembatalan Konteks. Jika goroutine yang diberikan selesai sebelum Konteks dibatalkan, isyarat siapnya dihantar melalui kaedah Done().

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

go func(ctx context.Context) {
      select {
             case <-ctx.Done():
                 fmt.Println("Exiting goroutine")
                 return
             default:
                  fmt.Println("Processing...")
       }
}(ctx)

// Exit after 5 sec
time.AfterFunc(5*time.Second, cancel)

Di sini kami menggunakan Done() dan cawangan lalai dalam goroutine. Jika Konteks dibatalkan atau tamat tempoh, kaedah Done() mengembalikan isyarat dan memanggil fungsi cancel() untuk membatalkan goroutine berjalan.

Dalam fungsi utama, kami menggunakan fungsi masa.AfterFunc() untuk memanggil fungsi pembatalan() Konteks ini untuk menandakan status pembatalan Konteks. Ini akan mencetuskan pembatalan goroutine selepas 5 saat.

4. Context超时和取消

在处理请求的时间，我们通常需要确保 goroutine 不会无限期地等待，而需要在可接受的时间范围内执行操作。

在下面的代码段中，我们将使用 context.WithTimeout() 函数创建一个带有 5 秒超时限制的 Context。

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

select {
    case <-time.After(5 * time.Second):
       fmt.Println("Request completed")
    case <-ctx.Done():
         fmt.Println("Exit due to: ", ctx.Err())
}

我们也使用了 cancel() 函数，确保 Context 被取消时自动触发。

为了模拟一个长时间的操作，我们使用 time.After(channel)。 当 goroutine 执行时间超过 2 秒时，Context 始终会被取消。 select 语句通过检查两个 channel 的操作结果而“安全地”退出。

总结

在 Go 语言中，Context 是通用工具，用于管理请求范围的数据。它提供了一种非常强大，灵活的方法，以跨 API 边界传递请求范围的值，如取消信号、截止日期、请求 ID 等。

在本文中，我们深入探讨了 Go Context 的一些实际用例，并讨论了一些最佳实践，以优化应用程序的可维护性和性能。

随着应用程序和网络的规模增长，Context 的正确使用和管理变得非常重要。如果用得当，它可以提高应用程序的健壮性和性能，从而确保进行细粒度的请求管理。

Atas ialah kandungan terperinci Ketahui lebih lanjut tentang penggunaan Go Context. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!