Cara golang serentak

Dalam pembangunan perisian moden, pengaturcaraan serentak telah menjadi salah satu kemahiran penting. Bahasa Go ialah bahasa yang direka khas untuk pengaturcaraan serentak, Goroutines, Saluran, Mutex dan mekanisme lain yang terbina dalam boleh memudahkan kerumitan pengaturcaraan serentak. Artikel ini akan memperkenalkan cara melaksanakan pengaturcaraan serentak dalam bahasa Go, memberikan anda pengetahuan asas dan kemahiran praktikal supaya anda boleh menulis program serentak dengan lebih cekap.

1. Apakah itu pengaturcaraan serentak

Biasanya, kami mempunyai pelbagai tugas untuk diproses dalam perisian, seperti membaca berbilang fail pada masa yang sama atau mendapatkan data daripada berbilang pangkalan data. Pengaturcaraan serentak adalah untuk membuat beberapa bahagian program dilaksanakan pada masa yang sama untuk meningkatkan kecekapan program dalam memproses tugas. Dalam pengaturcaraan serentak, kita perlu mengelakkan konflik antara pelbagai tugas dan memastikan ketepatan dan kebolehselenggaraan kod.

2. Goroutine dan Saluran

Groutine dan Saluran dalam bahasa Go ialah mekanisme teras untuk melaksanakan pengaturcaraan serentak.

Groutine ialah utas ringan dalam bahasa Go Memulakan Goroutine baharu melalui kata kunci go membolehkan program melaksanakan berbilang tugas pada masa yang sama. Goroutine boleh melaksanakan dalam ruang alamat yang sama dan boleh menukar benang dengan mudah tanpa overhed untuk mencipta benang, memusnahkan benang dan menukar konteks seperti urutan sistem pengendalian.

Saluran ialah cara pemesejan antara Goroutine dalam bahasa Go. Melalui Saluran, Goroutines boleh bertukar-tukar data dengan selamat dan mengelakkan perlumbaan data. Saluran boleh dianggap sebagai paip, yang menghantar mesej (data) dalam satu Goroutine dan menerima mesej (data) dalam Goroutine yang lain, merealisasikan komunikasi antara dua Goroutine.

Berikut ialah contoh mudah menggunakan Goroutines dan Saluran untuk melaksanakan pengiraan serentak:

package main

import (
    "fmt"
    "time"
)

func main() {
    start := time.Now()
    c := make(chan int)
    go calculateSum(c)
    sum := <-c
    end := time.Now()
    fmt.Printf("Sum: %v
Time: %v", sum, end.Sub(start))
}

func calculateSum(c chan int) {
    sum := 0
    for i := 0; i < 1000000000; i++ {
        sum += i
    }
    c <- sum
}

Dalam contoh ini, kami memulakan Goroutine baharu untuk mengira jumlah terkumpul daripada 0 hingga 100 juta , dan lulus hasilnya ke Goroutine utama melalui Saluran. Dengan menggunakan Goroutine dan Saluran, kami boleh melaksanakan tugas lain semasa proses pengiraan dan meningkatkan kecekapan program.

3. Mutex

Dalam pengaturcaraan serentak, kita perlu mengawal akses kepada sumber yang dikongsi untuk mengelakkan persaingan dan ralat data. Bahasa Go menyediakan Mutex (mutex lock) untuk melaksanakan kawalan akses selamat kepada sumber yang dikongsi. Mutex boleh memastikan bahawa hanya satu Goroutine boleh mengakses sumber yang dikongsi pada masa yang sama, dan Goroutine lain mesti menunggu Mutex dibuka kuncinya sebelum mereka boleh terus mengakses.

Berikut ialah contoh penggunaan Mutex untuk memastikan akses selamat kepada pembolehubah kongsi:

package main

import (
    "fmt"
    "sync"
)

var count int
var wg sync.WaitGroup
var mutex sync.Mutex

func main() {
    wg.Add(2)
    go increment()
    go increment()
    wg.Wait()
    fmt.Println("Count:", count)
}

func increment() {
    defer wg.Done()
    for i := 0; i < 1000000; i++ {
        mutex.Lock()
        count++
        mutex.Unlock()
    }
}

Dalam contoh ini, kami memulakan dua Goroutines untuk menambah pembolehubah kiraan dikongsi 1 juta kali beroperasi. Sebelum setiap Goroutine menambah pembolehubah kiraan, kami menggunakan Mutex untuk mengunci pembolehubah untuk memastikan bahawa hanya satu Goroutine boleh mengakses pembolehubah pada masa yang sama.

4. Gunakan semaphore untuk mengawal concurrency

Selain menggunakan Mutex untuk mengawal akses kepada sumber yang dikongsi, kami juga boleh menggunakan semaphore untuk mengawal concurrency untuk mengelakkan sistem daripada ranap disebabkan oleh concurrency yang berlebihan.

Semaphore ialah teknologi pengaturcaraan serentak klasik dalam sistem pengendalian Ia boleh mengawal bilangan sumber dikongsi yang diakses pada masa yang sama, tidak seperti Mutex, yang hanya mempunyai satu Goroutine boleh diakses pada bila-bila masa. Pakej penyegerakan dalam bahasa Go menyediakan sokongan untuk semaphore, yang boleh mengawal bilangan Goroutine serentak dengan mudah.

Berikut ialah contoh menggunakan semaphore untuk mengawal bilangan Goroutines serentak:

package main

import (
    "fmt"
    "sync"
)

var wg sync.WaitGroup
var semaphore = make(chan struct{}, 2) // 最多允许2个Goroutine并发访问

func main() {
    for i := 0; i < 5; i++ { // 开启5个任务
        wg.Add(1)
        go runTask(i)
    }
    wg.Wait()
}

func runTask(i int) {
    defer wg.Done()
    semaphore <- struct{}{} // 加锁，占用1个slot
    defer func() {
        <-semaphore // 解锁，释放1个slot
    }()

    fmt.Printf("Task %d start
", i)
    // do something
    fmt.Printf("Task %d end
", i)
}

Dalam contoh ini, kami menggunakan Saluran dengan kapasiti 2 sebagai semaphore, yang boleh membenarkan sehingga 2 Goroutine berjalan serentak. Setiap Goroutine memperoleh slot semaphore apabila memulakan tugas, dan melepaskan semaphore selepas menyelesaikan tugasan. Apabila sudah terdapat dua Goroutine yang sedang berjalan, Goroutines berikutnya mesti menunggu tugasan sedia ada untuk menyelesaikan dan melepaskan semaphore sebelum mereka boleh mula berjalan.

Dengan menggunakan semaphore, kami boleh mengawal bilangan tugas serentak dengan berkesan dan mengelakkan kekurangan sumber atau ranap yang disebabkan oleh penyelarasan sistem yang berlebihan.

5 Ringkasan

Pengaturcaraan serentak ialah kemahiran penting dalam pembangunan perisian moden menyediakan mekanisme Goroutine dan Saluran yang mudah dan mudah digunakan, serta mekanisme lanjutan seperti Mutex dan. semaphore adalah mudah untuk kita mencapai pengaturcaraan serentak yang cekap dan selamat. Apabila menggunakan mekanisme ini, kita perlu memberi perhatian kepada pengurusan persaingan data dan sumber yang dikongsi untuk memastikan ketepatan dan kebolehselenggaraan program. Melalui pengenalan artikel ini, anda sepatutnya sudah tahu cara menggunakan mekanisme seperti Goroutines, Channels, Mutex, dan semaphore untuk pengaturcaraan serentak, dan boleh menulis program serentak yang cekap dan selamat.

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