Bagaimana untuk melaksanakan asynchronous dalam golang

Dengan pembangunan berterusan teknologi Internet, aplikasi moden mempunyai permintaan yang lebih tinggi dan lebih tinggi untuk prestasi dan kebolehskalaan. Untuk memenuhi keperluan ini, beberapa bahasa pengaturcaraan dan rangka kerja mula menyokong pengaturcaraan tak segerak. Dalam artikel ini, kami akan memberi tumpuan kepada cara Golang melaksanakan pengaturcaraan tak segerak.

Apakah itu pengaturcaraan tak segerak?

Pengaturcaraan tak segerak ialah teknik pengaturcaraan di mana kod tidak disekat semasa melaksanakan secara berurutan. Sebaliknya, ia menggunakan teknik seperti fungsi panggil balik, dipacu peristiwa atau coroutine untuk menyokong operasi serentak semasa pelaksanaan kod. Pengaturcaraan tak segerak boleh meningkatkan prestasi program dan juga menjadikan program lebih berskala dan fleksibel.

Bagaimanakah Golang melaksanakan pengaturcaraan tak segerak?

Golang menyokong goroutin dan saluran, kedua-duanya adalah kunci untuk mencapai pengaturcaraan tak segerak. Coroutine ialah utas ringan di Golang yang menyokong pelaksanaan serentak dan boleh berkomunikasi menggunakan saluran. Saluran ialah mekanisme untuk memindahkan data antara coroutine Golang.

Coroutine

Coroutine boleh dianggap sebagai "sub-utas" dalam proses Ia boleh dilaksanakan serentak dalam proses dan merupakan unit asas pengaturcaraan serentak dalam bahasa Go. Pelaksanaan coroutine diselaraskan oleh penjadual, dan pengaturcara tidak perlu mengawalnya secara langsung, jadi ia boleh ditukar dengan mudah dengan bebas. Penciptaan coroutine adalah sangat mudah, hanya gunakan kata kunci go:

go func() {
    // do something in a goroutine
}()

Di sini, kami menggunakan fungsi tanpa nama untuk mewakili tugasan yang perlu dilakukan dalam coroutine. Apabila kami mencipta coroutine menggunakan kata kunci go dalam Golang, badan fungsi akan dilaksanakan secara tidak segerak dalam coroutine baharu.

Saluran

Seperti coroutine, saluran di Golang juga merupakan mekanisme ringan untuk menghantar data antara coroutine yang berbeza. Saluran mempunyai dua operasi utama: menghantar data dan menerima data. Kami boleh menggunakan kata kunci saluran untuk mencipta saluran:

ch := make(chan int)

Di sini, kami mencipta saluran bernama ch, yang boleh menghantar data jenis integer. Kod sampel untuk menghantar data dan menerima data adalah seperti berikut:

// Send data
ch <- 1

// Receive data
data := <-ch

Dalam kod di atas, kami menghantar data (1) ke saluran ch dan menerima data daripada saluran ch menggunakan operator <-, akan The data disimpan dalam pembolehubah data.

Coroutine + Channel

Coroutine dan saluran di Golang sering digunakan bersama untuk membentuk model pengaturcaraan tak segerak dipacu peristiwa. Dalam model pengaturcaraan ini, program melaksanakan tugas secara tak segerak melalui coroutine, dan berkomunikasi antara tugas melalui saluran untuk mencapai operasi serentak.

Kod berikut menunjukkan cara menggunakan coroutine dan saluran untuk melaksanakan tugasan secara tak segerak:

// Create a new channel
ch := make(chan int)

// Start a new goroutine to execute the task
go func() {
    // Do some time-consuming operation
    time.Sleep(1 * time.Second)

    // Send the result back to the channel
    ch <- 1
}()

// Wait for the result and print it
result := <-ch
fmt.Println(result)

Dalam kod di atas, kami mencipta saluran bernama ch dan melaksanakannya secara tak segerak menggunakan Coroutines Task (1 penggunaan kali kedua). Sebaik sahaja tugasan selesai, kami menghantar keputusan kembali ke saluran. Seterusnya, kami menggunakan <-ch untuk menunggu dan menerima keputusan, dan akhirnya mencetak hasilnya. Dengan cara ini, kami berjaya melaksanakan pengaturcaraan tak segerak.

Ringkasan

Dalam artikel ini, kami memperkenalkan dua mekanisme teras untuk melaksanakan pengaturcaraan tak segerak di Golang: coroutine dan saluran. Menggunakan kedua-dua mekanisme ini, kami boleh melaksanakan operasi serentak dengan mudah di Golang untuk meningkatkan prestasi program dan kebolehskalaan.

Pengaturcaraan tak segerak ialah salah satu teknologi yang diperlukan untuk pembangunan aplikasi moden, dan mekanisme coroutine dan saluran Golang menjadikan pengaturcaraan tak segerak lebih mudah, lebih mudah difahami dan dilaksanakan. Dengan mempelajari pengetahuan ini, kita boleh menulis program yang lebih cekap dan fleksibel untuk memenuhi keperluan perniagaan yang semakin berkembang.

Atas ialah kandungan terperinci Bagaimana untuk melaksanakan asynchronous dalam golang. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!