Bagaimana untuk serentak data dalam golang

Bahasa Go ialah bahasa yang direka dengan pengaturcaraan serentak sebagai fokusnya. Ia mempunyai benang ringan (iaitu goroutine) dan mekanisme komunikasi yang boleh dilanjutkan, menjadikannya sangat cekap apabila memproses data serentak. Artikel ini akan memperkenalkan cara menggunakan goroutin dan saluran untuk melaksanakan pemprosesan data serentak dalam Go.

Groutine ialah benang ringan yang diuruskan oleh sistem masa jalan Go. Tidak seperti model benang tradisional, goroutin dicipta dan dimusnahkan dengan sangat cepat dan membenarkan pembangun menjalankan beribu-ribu gorouti pada masa yang sama, yang menjadikan Go sangat sesuai untuk memproses data serentak.

Untuk mencipta goroutine, kita boleh menggunakan kata kunci go, contohnya:

go func() {
    // goroutine的执行代码
}()

Apabila menggunakan kata kunci go, kami akan melaksanakan fungsi tanpa nama dalam goroutine baharu. Fungsi ini boleh mengakses pembolehubah dalam skop semasa, jadi ia sangat mudah apabila menulis kod tak segerak.

Malah, proses penggunaan goroutine untuk memproses data serentak adalah serupa dengan proses menggunakan fungsi biasa untuk memproses data. Sebagai contoh, katakan kita mempunyai kepingan jenis int yang mengandungi 100 elemen dan kita ingin menambah 1 pada semua elemennya dan mengira jumlahnya, kita boleh menulis seperti ini:

func main() {
    nums := []int{1, 2, 3, ..., 100}
    sum := 0
    for _, num := range nums {
        go func(n int) {
            sum += n + 1
        }(num)
    }
    time.Sleep(time.Second) // 等待所有goroutine完成
    fmt.Println(sum) // 输出10100
}

Dalam kod di atas, kita akan Mulakan goroutine untuk setiap elemen dan tambah 1 padanya, kemudian tambah keputusan untuk mengira jumlahnya. Perlu diingatkan bahawa memandangkan goroutin dilaksanakan secara tidak segerak, kita perlu menggunakan time.Sleep untuk menunggu semua goroutin selesai.

Memanggil goroutine di dalam kaedah menghasilkan goroutine baharu pada tindanan panggilan yang berkongsi timbunan dan tindanan dengan goroutine asal dan mempunyai akses kepada pembolehubah yang sama. Pendekatan konkurensi ini membolehkan kami memproses data secara serentak dengan cekap. Walau bagaimanapun, adalah penting untuk ambil perhatian bahawa memandangkan pembolehubah yang dikongsi boleh menyebabkan perlumbaan data, kita mesti memastikan akses serentak kepada pembolehubah yang dikongsi disegerakkan.

Untuk menyelesaikan masalah ini, Go menyediakan saluran. Saluran ialah mekanisme penyegerakan yang membenarkan gorouti menghantar dan menerima data dengan selamat antara gorouti. Kita boleh menggunakan fungsi make untuk mencipta saluran, contohnya:

ch := make(chan int)

Ini akan mencipta saluran dengan jenis int dan kita boleh meletakkan beberapa nilai dalam cachenya, atau menghantar dan menerima nilai.

Untuk menghantar data ke saluran, gunakan operator <-:

ch <- 1 // 将1发送到通道

Untuk menerima data, anda boleh menggunakan operator <-, contohnya:

x := <-ch // 从通道中接收一个值，并将其赋值给x

Operasi saluran adalah menyekat, ini Maksudnya jika kita cuba menerima data dari saluran kosong, program akan disekat sehingga ada data yang boleh dihantar. Begitu juga, jika kita cuba menghantar data ke saluran yang penuh, program akan disekat sehingga goroutine lain boleh menerima data tersebut.

Kami boleh menggunakan saluran untuk menyegerakkan data antara goroutine. Sebagai contoh, katakan kita mempunyai saluran yang menerima dua nombor daripada saluran setiap kali dan menambahnya bersama-sama. Berikut ialah contoh mudah:

func sum(ch chan int, nums ...int) {
    for _, n := range nums {
        ch <- n
    }
    close(ch)
}

func main() {
    ch := make(chan int)
    go sum(ch, 1, 2, 3, 4, 5) // 将1,2,3,4,5发送到通道ch中

    sum := 0
    for n := range ch {
        sum += n
    }
    fmt.Println(sum) // 输出15
}

Dalam contoh di atas, kami mula-mula mencipta saluran ch dan memulakan goroutine fungsi sum yang menerima sebarang nombor dan meletakkan Ia dihantar ke saluran. Kemudian, dalam fungsi utama, kami menggunakan gelung mudah untuk membaca data daripada saluran dan menambahkannya bersama-sama.

Perlu diambil perhatian bahawa operasi saluran disekat, jadi beri perhatian khusus kepada isu kebuntuan apabila menggunakan saluran. Jika kami menghantar data ke saluran yang ditutup sebelum membaca data, atau membaca data daripada saluran yang sudah kosong, program akan menyekat dan tidak akan keluar.

Ringkasnya, model konkurensi bahasa Go sangat sesuai untuk memproses data serentak, dan pemprosesan serentak yang cekap boleh dicapai dengan mudah menggunakan goroutin dan saluran. Walau bagaimanapun, apabila menggunakan model konkurensi, anda perlu berhati-hati terutamanya tentang perlumbaan data dan kebuntuan untuk memastikan ketepatan dan keberkesanan program.

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