Apakah kaedah penulisan selari dalam golang?

Dalam pembangunan perisian moden, penggunaan sumber perkakasan komputer yang cekap adalah penting. Pengaturcaraan selari adalah kaedah pengaturcaraan yang boleh memaksimumkan penggunaan CPU berbilang teras. Berbanding dengan bahasa pengaturcaraan lain, bahasa Go (juga dipanggil Golang) mempunyai alat dan mekanisme terbina dalam untuk menyokong pengaturcaraan serentak, jadi ia telah digunakan secara meluas dan diiktiraf dalam bidang pengaturcaraan selari.

Artikel ini akan memperkenalkan beberapa kaedah dan teknologi untuk melaksanakan pengaturcaraan selari di Golang, serta senario dan langkah berjaga-jaga yang berkenaan.

1. Goroutine dan Saluran

Goroutine ialah model pengaturcaraan selari yang dipinjam oleh Golang daripada bahasa pengaturcaraan lain. Dikenali sebagai benang ringan, ia menjadikan penggunaan kuasa pemprosesan berbilang teras komputer anda dengan lebih cekap. Setiap Goroutine diurus secara automatik oleh sistem masa jalan Golang dan pembangun hanya perlu mencipta Goroutine dengan menjalankan kata kunci go.

Contohnya:

func main() {
    go func() {
        fmt.Println("Hello, Goroutine!")
    }()
    fmt.Println("Hello, World!")
}

Dalam kod ini, kami mencipta fungsi tanpa nama dan menukarnya menjadi Goroutine menggunakan kata kunci go. Program ini akan mengeluarkan "Hello, World!" dan "Hello, Goroutine!"

Saluran ialah mekanisme yang digunakan untuk komunikasi antara Goroutine di Golang. Saluran boleh digunakan untuk menghantar sebarang jenis data, jadi data dan maklumat kawalan boleh dihantar antara Goroutine yang berbeza.

Contohnya:

func worker(id int, jobs <-chan int, results chan<- int) {
    for j := range jobs {
        fmt.Println("worker", id, "started  job", j)
        time.Sleep(time.Second)
        fmt.Println("worker", id, "finished job", j)
        results <- j * 2
    }
}

func main() {
    jobs := make(chan int, 100)
    results := make(chan int, 100)
    for w := 1; w <= 3; w++ {
        go worker(w, jobs, results)
    }
    for j := 1; j <= 9; j++ {
        jobs <- j
    }
    close(jobs)
    for a := 1; a <= 9; a++ {
        <-results
    }
}

Dalam kod ini, kami mentakrifkan fungsi pekerja yang menerima dua Saluran: satu untuk menerima tugas dan satu lagi untuk mengembalikan hasil tugas . Kami mencipta tiga Goroutine Setiap Goroutine akan mendapatkan tugas daripada Saluran kerja dan menulis hasil pemprosesan ke Saluran hasil. Akhir sekali, kami menggunakan gelung for untuk menghantar 9 tugasan ke Saluran kerja dan mengeluarkan nilai hasil Saluran ke output standard. Ambil perhatian bahawa kita perlu menutup Saluran kerja selepas gelung untuk supaya fungsi pekerja ditamatkan.

2. Pakej Sync

Di Golang, pakej Sync menyediakan beberapa alat penyegerakan yang diperlukan untuk pengaturcaraan selari, seperti:

· WaitGroup: Tunggu sekumpulan Goroutines untuk menyelesaikan tugas ;
· Mutex: melaksanakan akses eksklusif bersama kepada data yang dikongsi;
· Syarat: pembolehubah syarat untuk komunikasi dan penyegerakan antara berbilang Goroutine.

Di sini kami akan menunjukkan contoh penggunaan WaitGroup:

func worker(id int, wg *sync.WaitGroup) {
    defer wg.Done()
    fmt.Printf("Worker %d starting\n", id)

    time.Sleep(time.Second)
    fmt.Printf("Worker %d done\n", id)
}

func main() {
    var wg sync.WaitGroup

    for i := 1; i <= 5; i++ {
        wg.Add(1)
        go worker(i, &wg)
    }

    wg.Wait()
}

Dalam contoh ini, kami mentakrifkan fungsi pekerja yang menerima penunjuk WaitGroup sebagai parameter. Selepas kerja fungsi selesai, kami memanggil kaedah Selesai WaitGroup untuk memberitahu tugas Goroutine yang menjadi miliknya telah selesai. Dalam fungsi utama, kami mencipta Goroutine untuk setiap fungsi pekerja dan menggunakan kaedah Tambah WaitGroup untuk memberitahu WaitGroup bahawa terdapat sekumpulan Goroutine yang berjalan di sini. Akhir sekali, kami memanggil kaedah Tunggu untuk menunggu semua Goroutine menyelesaikan tugas mereka.

3. Tetapkan GOMAXPROCS

Di Golang, GOMAXPROCS ialah nombor yang menunjukkan bilangan Goroutine yang perlu dijalankan pada masa yang sama. Jika nombor ini ditetapkan terlalu kecil, keselarian program akan dihadkan. Jika ditetapkan terlalu besar, sumber komputer akan dibazirkan. Oleh itu, kita perlu menetapkan nilai GOMAXPROCS mengikut bilangan teras pemproses komputer untuk mengelakkan penggunaan sumber komputer yang berlebihan atau kurang.

Secara lalai, GOMAXPROCS Golang adalah sama dengan bilangan teras pemproses Anda boleh menggunakan pakej runtime untuk mengubah suainya dalam kod program:

import "runtime"

//...

func main() {
    numCPU := runtime.NumCPU()
    runtime.GOMAXPROCS(numCPU)

    //...
}

Di sini, kami menggunakan pakej runtime. untuk mendapatkan bilangan pemprosesan teras pemproses, dan kemudian tetapkan nilai GOMAXPROCS sama dengan bilangan teras.

Ringkasan

Artikel ini memperkenalkan beberapa kaedah dan teknologi pengaturcaraan serentak di Golang, termasuk Goroutine dan Saluran, pakej Penyegerakan dan menyediakan GOMAXPROCS. Walaupun pengaturcaraan serentak boleh meningkatkan prestasi dan kecekapan program, ia juga membawa beberapa risiko dan cabaran. Oleh itu, apabila melakukan pengaturcaraan serentak, kita perlu memilih penyelesaian yang sesuai berdasarkan situasi sebenar, dan memberi perhatian kepada mengawal tahap keselarian untuk mengelakkan kesilapan yang tidak perlu dan pembaziran sumber.

Atas ialah kandungan terperinci Apakah kaedah penulisan selari dalam golang?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!