Menganalisis misteri pengaturcaraan berbilang benang Golang

Menyahsulit rahsia pengaturcaraan berbilang benang di Golang memerlukan contoh kod khusus

Dalam bidang pembangunan perisian hari ini, pengaturcaraan berbilang benang telah menjadi keperluan biasa. Pengaturcaraan berbilang benang boleh menggunakan sepenuhnya kelebihan pemproses berbilang teras untuk meningkatkan kecekapan berjalan dan kelajuan tindak balas program. Walau bagaimanapun, pengaturcaraan berbilang benang juga membawa beberapa cabaran, seperti keselamatan benang, penyegerakan dan pertikaian sumber.

Golang ialah bahasa pengaturcaraan sumber terbuka yang menyokong pengaturcaraan berbilang benang secara asli dan menyediakan model serentak yang berkuasa. Artikel ini akan mendedahkan misteri pengaturcaraan berbilang benang di Golang dan menyediakan beberapa contoh kod khusus untuk membantu pembaca memahami dan menggunakan.

1. goroutine

Groutine di Golang ialah benang ringan yang boleh mencipta beribu-ribu goroutine dalam program tanpa menyebabkan overhed yang ketara. Kita boleh menggunakan kata kunci go untuk mencipta goroutine dan menggunakan fungsi tanpa nama untuk membungkus blok kod yang perlu dijalankan.

package main

import "fmt"

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

    // 等待goroutine执行完成
    time.Sleep(time.Second)
}

Dalam contoh di atas, goroutine dibuat menggunakan kata kunci go, yang akan melaksanakan fungsi tanpa nama fmt.Println("Hello, World!") secara tak segerak di latar belakang. Ambil perhatian bahawa untuk memastikan pelaksanaan goroutine selesai, utas utama perlu menunggu untuk tempoh masa tertentu Kami menggunakan fungsi masa.Sleep untuk berhenti seketika.

2. saluran

Golang menggunakan saluran untuk melaksanakan komunikasi antara goroutin. Saluran ialah struktur data selamat jenis, selamat serentak yang boleh digunakan untuk operasi baca dan tulis. Kita boleh menggunakan fungsi make terbina dalam untuk mencipta saluran dan menggunakan operator

package main

import "fmt"

func main() {
    ch := make(chan int)

    go func() {
        ch <- 42
    }()

    value := <-ch
    fmt.Println(value)
}

Dalam contoh di atas, kami mencipta saluran integer dan menghantar nilai 42 ke saluran dalam goroutine. Dalam urutan utama, kami menggunakan

3. Keselamatan Concurrency

Dalam pengaturcaraan berbilang benang, persaingan sumber adalah masalah yang sangat biasa. Bagi menyelesaikan masalah persaingan sumber, Golang menyediakan kunci mutex dan kunci baca-tulis.

Mutex ialah kunci eksklusif yang hanya membenarkan satu goroutine mengakses sumber terkunci. Kita boleh menggunakan Mutex daripada pakej penyegerakan untuk mencipta mutex dan menggunakan kaedah Kunci dan Buka Kuncinya untuk mengunci dan membuka kunci sumber.

package main

import (
    "fmt"
    "sync"
)

var (
    count int
    mutex sync.Mutex
)

func main() {
    for i := 0; i < 1000; i++ {
        go increment()
    }

    // 等待所有goroutine执行完成
    time.Sleep(time.Second)
    fmt.Println(count)
}

func increment() {
    mutex.Lock()
    count++
    mutex.Unlock()
}

Dalam contoh di atas, kami menggunakan mutex kunci mutex untuk melindungi akses kepada kiraan pembolehubah yang dikongsi. Dalam fungsi kenaikan, gunakan kaedah mutex.Lock dan mutex.Unlock untuk mengunci dan membuka kunci apabila mengemas kini pembolehubah kiraan.

Kunci baca-tulis (RWMutex) ialah kunci yang lebih fleksibel yang membenarkan berbilang goroutin membaca sumber yang dikongsi pada masa yang sama, tetapi hanya membenarkan satu goroutin menulis untuk melaksanakan operasi tulis. Kita boleh menggunakan RWMutex dalam pakej penyegerakan untuk mencipta kunci baca-tulis, dan menggunakan kaedah RLock dan RUnlocknya untuk operasi baca, dan kaedah Kunci dan Buka Kuncinya untuk operasi tulis.

4. select statement

Dalam pengaturcaraan serentak, selalunya perlu menunggu satu atau lebih berbilang gorout untuk menyelesaikan tugas tertentu sebelum meneruskan pelaksanaan. Golang menyediakan pernyataan pilihan untuk menyelesaikan masalah ini.

Pernyataan pilih digunakan untuk memilih satu daripada berbilang operasi komunikasi untuk pelaksanaan Setelah operasi komunikasi tertentu boleh dilaksanakan, operasi komunikasi yang selebihnya akan diabaikan. Kita boleh menggunakan pernyataan pilih untuk menunggu operasi baca dan tulis saluran, serta operasi tamat masa, dsb.

package main

import (
    "fmt"
    "time"
)

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

    go func() {
        time.Sleep(time.Second)
        ch1 <- "Hello"
    }()

    go func() {
        time.Sleep(2 * time.Second)
        ch2 <- "World"
    }()

    for i := 0; i < 2; i++ {
        select {
        case msg1 := <-ch1:
            fmt.Println(msg1)
        case msg2 := <-ch2:
            fmt.Println(msg2)
        }
    }
}

Dalam contoh di atas, kami mencipta dua saluran jenis rentetan dan menghantar data ke dua saluran ini dalam dua goroutine. Dalam urutan utama, kami menggunakan pernyataan pilih untuk menunggu data dalam dua saluran ini Setelah data boleh dibaca, ia akan dicetak.

Di atas adalah beberapa misteri dan kemahiran praktikal pengaturcaraan berbilang benang di Golang. Melalui ciri-ciri seperti goroutine, saluran, mutex, kunci baca-tulis dan penyataan pilih, kami boleh menulis program selamat serentak dengan mudah dan memanfaatkan kelebihan prestasi pemproses berbilang teras. Saya harap contoh di atas dapat membantu pembaca lebih memahami dan menggunakan pengaturcaraan berbilang benang di Golang.

Atas ialah kandungan terperinci Menganalisis misteri pengaturcaraan berbilang benang Golang. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!