Panduan Pengaturcaraan Serentak: Meneroka Paralelisme dalam Perpustakaan Standard Golang

Panduan Pengaturcaraan Serentak di Perpustakaan Standard Golang

Pengenalan:
Pengaturcaraan serentak ialah cara penting untuk menyelesaikan masalah prestasi program dan mencapai penggunaan sumber pengkomputeran yang cekap. Dalam bahasa pengaturcaraan Golang, pelbagai alatan dan kaedah pengaturcaraan serentak disediakan. Artikel ini akan memperkenalkan beberapa teknik pengaturcaraan serentak biasa dalam pustaka standard Golang, dan menggambarkan penggunaan dan langkah berjaga-jaganya melalui contoh kod tertentu.

1. Goroutine (Coroutine)
   Goroutine ialah benang ringan di Golang, dimulakan dengan kata kunci Go. Melalui Goroutine, kami boleh melaksanakan berbilang tugas pada masa yang sama dalam program untuk mencapai kesan pelaksanaan serentak yang tinggi. Berikut ialah contoh mudah Goroutine:

package main

import (
    "fmt"
    "time"
)

func printNumbers() {
    for i := 0; i < 5; i++ {
        fmt.Printf("%d ", i)
        time.Sleep(time.Millisecond * 500)
    }
}

func printLetters() {
    for i := 'A'; i < 'F'; i++ {
        fmt.Printf("%c ", i)
        time.Sleep(time.Millisecond * 500)
    }
}

func main() {
    go printNumbers()    // 启动一个Goroutine，打印数字
    go printLetters()    // 启动另一个Goroutine，打印字母

    time.Sleep(time.Second * 3)    // 等待两个Goroutine执行完毕
    fmt.Println("Done")
}

Dalam kod di atas, kami menentukan dua fungsi printNumbers dan printLetters masing-masing dan lulus go Kod> kata kunci memulakannya sebagai dua Goroutine masing-masing. Gunakan fungsi time.Sleep untuk menunggu dua Goroutine menyelesaikan pelaksanaan Anda boleh melihat bahawa nombor dan huruf dikeluarkan secara bergilir-gilir dalam hasil output. printNumbers和printLetters两个函数，并通过go关键字将它们分别启动为两个Goroutine。通过time.Sleep函数等待两个Goroutine执行完毕，可以看到输出结果中数字和字母是交替输出的。

2. Channel（通道）
   在Golang中，Goroutine之间的通信使用Channel（通道）来完成。Channel是一种类型安全的队列，用于在Goroutine之间传递数据。下面是一个简单的Channel示例：

package main

import (
    "fmt"
    "time"
)

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

func main() {
    numJobs := 5
    jobs := make(chan int, numJobs)
    results := make(chan int, numJobs)

    numWorkers := 3
    for w := 1; w <= numWorkers; w++ {
        go worker(w, jobs, results)
    }

    for j := 1; j <= numJobs; j++ {
        jobs <- j
    }
    close(jobs)

    for a := 1; a <= numJobs; a++ {
        result := <-results
        fmt.Println("Result:", result)
    }
}

在上述代码中，我们定义了worker函数，该函数用于接收jobs通道传入的数字，并进行相应的处理，结果通过results通道返回。在主函数中，我们分别创建了jobs和results两个通道，并将jobs通道传递给三个Goroutine执行。然后，通过for循环向jobs通道发送5个作业，并关闭通道。最后，通过for循环接收results通道的返回结果并输出。

3. WaitGroup（等待组）
   在并发编程中，经常需要等待多个Goroutine的全部执行完成后再进行下一步的操作。Golang中的sync包提供了WaitGroup类型来实现这个功能。下面是一个使用WaitGroup的示例：

package main

import (
    "fmt"
    "sync"
    "time"
)

func worker(id int, wg *sync.WaitGroup) {
    defer wg.Done()
    fmt.Printf("Worker %d starting
", id)
    time.Sleep(time.Second)
    fmt.Printf("Worker %d done
", id)
}

func main() {
    var wg sync.WaitGroup

    numWorkers := 3
    wg.Add(numWorkers)
    for w := 1; w <= numWorkers; w++ {
        go worker(w, &wg)
    }

    wg.Wait()
    fmt.Println("All workers done")
}

在上述代码中，我们定义了worker函数，该函数接收一个WaitGroup参数，执行相应的任务，并在任务执行完成后通过Done方法通知WaitGroup。在主函数中，我们创建了一个WaitGroup变量，并通过Add方法指定需要等待的Goroutine数量。然后，使用go关键字启动相应数量的Goroutine，并将WaitGroup指针传递给每个Goroutine。最后，通过Wait

Saluran

Di Golang, komunikasi antara Goroutines diselesaikan menggunakan Saluran. Saluran ialah baris gilir selamat jenis yang digunakan untuk menghantar data antara Goroutines. Berikut ialah contoh Saluran mudah:


rrreee🎜Dalam kod di atas, kami mentakrifkan fungsi worker, yang digunakan untuk menerima nombor yang dihantar oleh saluran kerja dan memprosesnya dengan sewajarnya lulus Keputusan saluran pulangan. Dalam fungsi utama, kami mencipta dua saluran, pekerjaan dan hasil, masing-masing, dan menyerahkan saluran pekerjaan kepada tiga Goroutine untuk dilaksanakan. Kemudian, hantar 5 kerja ke saluran kerja melalui gelung untuk dan tutup saluran. Akhir sekali, hasil pulangan saluran hasil diterima melalui gelung untuk dan keluaran. 🎜
🎜WaitGroup (kumpulan menunggu)🎜Dalam pengaturcaraan serentak, selalunya perlu menunggu untuk selesai semua pelaksanaan berbilang Goroutine sebelum meneruskan ke langkah seterusnya. Pakej sync dalam Golang menyediakan jenis WaitGroup untuk melaksanakan fungsi ini. Berikut ialah contoh penggunaan WaitGroup: 🎜🎜rrreee🎜Dalam kod di atas, kami mentakrifkan fungsi worker, yang menerima parameter WaitGroup, melaksanakan tugas yang sepadan dan lulus Done memberitahu WaitGroup. Dalam fungsi utama, kami mencipta pembolehubah WaitGroup dan menentukan bilangan Goroutine untuk menunggu melalui kaedah Tambah. Kemudian, gunakan kata kunci go untuk memulakan bilangan Goroutine yang sepadan dan hantar penuding WaitGroup kepada setiap Goroutine. Akhir sekali, tunggu sehingga semua pelaksanaan Goroutine selesai melalui kaedah Tunggu. 🎜🎜Ringkasan: 🎜Melalui alatan dan kaedah pengaturcaraan serentak yang disediakan dalam perpustakaan standard Golang, kami boleh melaksanakan program konkurensi tinggi dengan mudah. Artikel ini memperkenalkan teknik pengaturcaraan serentak biasa seperti Goroutine, Channel dan WaitGroup, dan menggambarkannya dengan contoh kod khusus. Saya berharap pembaca dapat menguasai kemahiran pengaturcaraan serentak di Golang dengan lebih baik dan meningkatkan prestasi dan kecekapan pengendalian program melalui kajian artikel ini. 🎜

Atas ialah kandungan terperinci Panduan Pengaturcaraan Serentak: Meneroka Paralelisme dalam Perpustakaan Standard Golang. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!