Ciri bahasa Golang didedahkan: pengkomputeran selari dan model konkurensi

Ciri bahasa Golang didedahkan: Pengkomputeran selari dan model konkurensi

Bahasa Go (Golang) ialah bahasa pengaturcaraan sumber terbuka yang dibangunkan oleh Google dan terkenal dengan reka bentuk yang ringkas dan cekap serta sokongan serentak yang sangat baik. Dalam artikel ini, kami akan meneroka model pengkomputeran selari dan konkurensi Golang dan cara ia boleh digunakan untuk meningkatkan prestasi program anda.

1. Pengkomputeran Selari

Pengkomputeran selari merujuk kepada keupayaan untuk melaksanakan pelbagai tugas pengkomputeran pada masa yang sama. Ia mempercepatkan pelaksanaan program dengan menggunakan berbilang pemproses atau teras pemproses. Di Golang, kita boleh menggunakan goroutin dan saluran untuk melaksanakan pengkomputeran selari.

1. Goroutine

Goroutine ialah unit pelaksanaan ringan di Golang, yang boleh dilaksanakan serentak dengan Goroutine lain. Berbanding dengan rangkaian sistem pengendalian, Goroutines dimulakan dan dimusnahkan dengan lebih cepat dan menggunakan lebih sedikit memori. Goroutine boleh dibuat menggunakan kata kunci go.

Berikut ialah contoh kod yang menggunakan Goroutine untuk mengira jujukan Fibonacci:

package main

import (
    "fmt"
)

func Fibonacci(n int, c chan int) {
    x, y := 0, 1
    for i := 0; i < n; i++ {
        c <- x
        x, y = y, x+y
    }
    close(c)
}

func main() {
    c := make(chan int)
    go Fibonacci(10, c)
    for i := range c {
        fmt.Println(i)
    }
}

Dalam contoh di atas, kami mencipta Goroutine untuk mengira jujukan Fibonacci dan menghantar hasil pengiraan ke utas utama melalui saluran. Benang utama membaca data daripada saluran melalui kata kunci julat dan mencetaknya ke konsol.

2. Saluran

Saluran boleh digunakan sebagai saluran paip untuk komunikasi antara Goroutines. Ia menyediakan mekanisme capaian serentak yang selamat yang menghalang berbilang Goroutines daripada mengakses dan mengubah suai data dikongsi pada masa yang sama.

Di Golang, anda boleh menggunakan fungsi make untuk membuat saluran. Saluran boleh ditimbal atau tidak ditimbal. Saluran buffer boleh menyimpan sejumlah data, manakala saluran tidak buffer hanya boleh menyimpan satu keping data pada satu masa.

Berikut ialah contoh kod yang menggunakan saluran untuk pengiraan selari:

package main

import (
    "fmt"
    "time"
)

func calculateSquare(number int, c chan int) {
    time.Sleep(1 * time.Second)
    c <- number * number
}

func main() {
    startTime := time.Now()

    c := make(chan int)

    for i := 1; i <= 3; i++ {
        go calculateSquare(i, c)
    }

    for i := 1; i <= 3; i++ {
        fmt.Println(<-c)
    }

    endTime := time.Now()
    elapsedTime := endTime.Sub(startTime)
    fmt.Printf("总计算时间：%s
", elapsedTime)
}

Dalam contoh di atas, kami mencipta fungsi yang mengira segi empat sama dan menghantar hasil pengiraan ke dalam saluran. Kemudian, 3 Goroutines dicipta dalam utas utama untuk melaksanakan tugas pengiraan secara serentak, dan hasilnya dibaca ke dalam utas utama melalui saluran untuk mencetak. Akhir sekali, kami menggunakan pakej masa untuk mengira dan mencetak jumlah masa pengiraan program.

2. Model Concurrency

Concurrency bermaksud berbilang tugasan dilaksanakan secara berselang-seli, tetapi tidak semestinya pada masa yang sama. Model concurrency ialah kaedah untuk mengurus dan menjadualkan berbilang tugas serentak. Di Golang, kita boleh menggunakan kunci mutex (Mutex) dan kunci baca-tulis (RWMutex) untuk mencapai akses data serentak.

1. Mutex (Mutex)

Mutex digunakan untuk melindungi sumber kongsi Hanya satu Goroutine dibenarkan untuk mengakses sumber kongsi dan Goroutine lain mesti menunggu pelepasan mutex sebelum mereka boleh mengakses. Kunci Mutex boleh dibuat menggunakan jenis Mutex daripada pakej penyegerakan.

Berikut ialah kod sampel yang menggunakan mutex untuk melaksanakan akses serentak kepada sumber yang dikongsi:

package main

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

var count int
var mutex sync.Mutex

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

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

    time.Sleep(2 * time.Second)
    fmt.Printf("最终值：%d
", count)
}

Dalam contoh di atas, kami mencipta kiraan pembolehubah global dan menggunakan mutex untuk melindungi akses serentaknya. Dalam setiap Goroutine, mula-mula gunakan kaedah Kunci untuk mendapatkan kunci mutex, dan kemudian gunakan kaedah Buka Kunci untuk melepaskan kunci mutex selepas fungsi tamat. Akhir sekali, kami mencetak nilai akhir kiraan.

2. Kunci baca-tulis (RWMutex)

Kunci baca-tulis digunakan untuk mengendalikan operasi baca dan tulis pada sumber yang dikongsi. Tidak seperti mutex, berbilang Goroutine boleh mengakses sumber yang dikongsi secara serentak untuk operasi baca, tetapi untuk operasi tulis, hanya satu Goroutine boleh mengaksesnya. Kunci baca-tulis boleh dibuat menggunakan jenis RWMutex daripada pakej penyegerakan.

Berikut ialah contoh kod yang menggunakan kunci baca-tulis untuk melaksanakan pembacaan dan penulisan serentak sumber yang dikongsi:

package main

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

var count int
var rwMutex sync.RWMutex

func read() {
    rwMutex.RLock()
    defer rwMutex.RUnlock()
    fmt.Println(count)
}

func write() {
    rwMutex.Lock()
    defer rwMutex.Unlock()
    count++
}

func main() {
    for i := 0; i < 10; i++ {
        go read()
        go write()
    }

    time.Sleep(2 * time.Second)
}

Dalam contoh di atas, kami mencipta kiraan pembolehubah global dan menggunakan kunci baca-tulis untuk melindungi bacaan serentaknya dan menulis. Dalam setiap Goroutine, kami menggunakan kaedah RLock untuk mendapatkan kunci baca untuk operasi baca, dan kaedah Kunci untuk mendapatkan kunci tulis untuk operasi tulis. Akhir sekali, kami menggunakan pakej masa untuk memastikan bahawa Goroutine mempunyai masa yang mencukupi untuk dilaksanakan.

Ringkasan:

Golang menyediakan pengkomputeran selari yang berkuasa dan sokongan model konkurensi, membolehkan kami menggunakan prestasi pemproses berbilang teras dan teras pemproses dengan lebih baik. Dengan menggunakan Goroutines dan saluran untuk melaksanakan pengkomputeran selari, kami boleh dengan cepat dan mudah melaksanakan program serentak yang cekap. Menggunakan kunci mutex dan kunci baca-tulis untuk mengurus akses serentak kepada sumber yang dikongsi boleh memastikan ketekalan dan kebolehpercayaan data. Dengan memahami dan menggunakan model pengkomputeran selari dan konkurensi Golang, kami boleh meningkatkan prestasi dan responsif program kami dengan lebih baik.

Atas ialah kandungan terperinci Ciri bahasa Golang didedahkan: pengkomputeran selari dan model konkurensi. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!