Konsep dan teknik pengaturcaraan serentak dalam bahasa Go

Dengan perkembangan berterusan teknologi komputer, CPU berbilang teras telah menjadi standard. Pengaturcaraan serentak sangat penting dalam pembangunan perisian hari ini, dan bahasa Go telah menjadi salah satu bahasa pengaturcaraan serentak yang paling popular kerana mekanisme konkurensinya yang unik. Dalam artikel ini, kita akan membincangkan konsep dan teknik pengaturcaraan serentak dalam bahasa Go.

1. Konsep konkurensi

Konkurensi bermaksud dua atau lebih peristiwa berlaku dalam selang masa yang sama. Dalam pengkomputeran, ini bermakna berbilang tugas boleh dilaksanakan secara serentak dalam selang masa yang sama. Pengaturcaraan serentak merujuk kepada teknologi pengaturcaraan untuk menulis program yang boleh melaksanakan pelbagai tugas pada masa yang sama.

Konsep pengaturcaraan serentak dan pengaturcaraan selari adalah berbeza. Pengaturcaraan serentak merujuk kepada melaksanakan berbilang tugas secara serentak, manakala pengaturcaraan selari merujuk kepada melaksanakan berbilang tugas secara serentak pada berbilang pemproses atau teras pemprosesan. Dalam bidang komputer, konkurensi dan paralelisme sering digunakan secara bergantian, tetapi pada asasnya ia berbeza.

2. Konkurensi dalam bahasa Go

Bahasa Go menyokong pengaturcaraan serentak dalam kedua-dua sintaks dan masa jalan. Goroutine dalam bahasa Go ialah utas yang sangat ringan A Goroutine hanya perlu mengisi sedikit ruang timbunan untuk dijalankan Pada masa yang sama, program Go boleh mempunyai beribu-ribu Goroutine, yang membolehkan program Go menjalankan tugas serentak dengan cekap.

Concurrency dalam bahasa Go mengguna pakai model concurrency CSP, yang berkongsi memori melalui komunikasi dan bukannya berkomunikasi melalui memori dikongsi. Dalam bahasa Go, kita boleh menggunakan saluran untuk melaksanakan komunikasi antara Goroutines.

Saluran boleh ditakrifkan dengan cara berikut:

ch := make(chan int)

Gunakan kata kunci go terbina dalam bahasa Go untuk memulakan Goroutine:

go printHelloWorld()

Dalam kod ini , printHelloWorld() ialah fungsi Goroutine yang dimulakan melalui kata kunci go akan dijalankan secara bebas dalam urutan baharu.

3. Kemahiran pengaturcaraan serentak

3.1 Gunakan saluran untuk menyelaraskan Goroutine

Seperti yang dinyatakan di atas, dalam bahasa Go, kita boleh menggunakan saluran untuk melaksanakan komunikasi Goroutine antara . Saluran boleh digunakan untuk penyelarasan antara dua atau lebih Goroutine dan untuk mengawal sumber yang dikongsi.

package main

import "fmt"

func hello(done chan bool) {
    fmt.Println("Hello world Goroutine")
    done <- true
}

func main() {
    done := make(chan bool)
    go hello(done)
    <-done
    fmt.Println("main function")
}

Dalam kod ini, kami mentakrifkan saluran hello() di luar fungsi done dan menghantarnya ke fungsi hello(). Dalam fungsi hello(), kami mencetak mesej dan menulis nilai true ke dalam saluran done, menunjukkan bahawa fungsi hello() telah selesai. Dalam fungsi main(), kita membaca data daripada saluran melalui sintaks <-done, tunggu sehingga fungsi hello() selesai dan tulis nilai true ke dalam saluran done. Dengan cara ini, kami mencapai penyelarasan Goroutine.

3.2 Menggunakan pernyataan pilih

Pernyataan pilih boleh digunakan untuk memproses berbilang operasi saluran pada masa yang sama. Dalam pernyataan pilih, kita boleh menentukan berbilang saluran dan kemudian memprosesnya melalui satu set pernyataan kes.

package main

import (
    "fmt"
    "time"
)

func main() {
    ch1 := make(chan int)
    ch2 := make(chan string)

    go func() {
        ch1 <- 1
    }()

    go func() {
        ch2 <- "hello"
    }()

    for i := 0; i < 2; i++ {
        select {
        case num := <-ch1:
            fmt.Println("ch1:", num)
        case str := <-ch2:
            fmt.Println("ch2:", str)
        case <-time.After(time.Millisecond * 100):
            fmt.Println("timeout")
        }
    }
}

Dalam kod ini, kami mentakrifkan dua saluran, ch1 dan ch2, dan memulakan dua Goroutine untuk menulis data ke dua saluran ini masing-masing. Dalam fungsi main(), kami memproses input kedua-dua saluran ini melalui gelung untuk, menggunakan pernyataan pilih untuk memilih salah satu saluran yang tersedia dan memproses inputnya. Jika tiada saluran tersedia dalam tempoh masa yang tetap, kami boleh menggunakan fungsi time.After() untuk melaksanakan pemprosesan tamat masa.

4. Kesimpulan

Dalam artikel ini, kami membincangkan konsep dan teknik pengaturcaraan serentak dalam bahasa Go. Melalui Goroutine dan saluran, kami boleh melaksanakan pengaturcaraan serentak dengan cekap. Apabila menulis atur cara serentak, kita harus mengikuti beberapa teknik asas, seperti menggunakan saluran untuk menyelaraskan Goroutine dan menggunakan penyataan pilih untuk menyegerakkan pelaksanaan berbilang Goroutine. Teknik ini boleh membantu kami menulis program serentak yang cekap dan stabil.

Atas ialah kandungan terperinci Konsep dan teknik pengaturcaraan serentak dalam bahasa Go. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!