Rumah  >  Artikel  >  pembangunan bahagian belakang  >  Panduan Pengaturcaraan Golang Concurrency: Meneroka Misteri Pemprosesan Selari

Panduan Pengaturcaraan Golang Concurrency: Meneroka Misteri Pemprosesan Selari

WBOY
WBOYasal
2024-05-31 09:10:57328semak imbas

Pengaturcaraan serentak dalam Go menggunakan benang ringan (Goroutine) dan mekanisme komunikasi (talian paip) untuk melaksanakan pelaksanaan tugas selari. Primitif penyegerakan (seperti mutex) digunakan untuk menyelaraskan akses antara Goroutines. Contoh praktikal termasuk mencipta perkhidmatan web serentak yang cekap untuk mengendalikan berbilang permintaan.

Panduan Pengaturcaraan Golang Concurrency: Meneroka Misteri Pemprosesan Selari

Panduan Pengaturcaraan Serentak dalam Go: Meneroka Misteri Pemprosesan Selari

Pengenalan

Pengaturcaraan serentak ialah aspek utama pembangunan perisian moden, membolehkan aplikasi melaksanakan pelbagai tugas secara serentak dan dengan itu meningkatkan kecekapan. Bahasa Go menjadikannya sesuai untuk membina aplikasi serentak melalui sokongan serentak yang sangat baik.

Asas Goroutine

Goroutine ialah utas ringan dalam Go, yang dimulakan dengan kata kunci go. Mereka berbeza daripada benang kerana mereka berkongsi ruang memori yang sama tetapi dijalankan dalam aliran pelaksanaan yang berbeza. go关键字启动。它们与线程不同,因为它们共享相同的内存空间,但运行在不同的执行流中。

在Go中创建一个Goroutine示例代码:

package main

import "fmt"

func main() {
    go func() {
        fmt.Println("Hello from goroutine")
    }()
    fmt.Println("Hello from main")
}

此代码创建一个Goroutine,它并发打印Hello from goroutine,同时主Goroutine打印Hello from main

通道用于通信

管道是Goroutine之间通信的一种机制。它们类似于缓冲队列,Goroutine可以使用它们发送和接收消息。

创建一个通道的示例代码:

package main

import "fmt"

func main() {
    c := make(chan int)
    go func() { c <- 10 }()
    v := <-c
    fmt.Println(v)
}

此代码创建一个管道c,一个Goroutine向通道发送值10,而主Goroutine从通道接收值并打印。

同步与等待

在并发编程中,同步对于确保Goroutine之间协调执行至关重要。Go提供了各种同步原语,例如互斥体、条件变量和等待组。

使用互斥体保护共享数据示例代码:

package main

import (
    "fmt"
    "sync"
)

func main() {
    var m sync.Mutex
    var count int
    go func() {
        m.Lock()
        count++
        m.Unlock()
    }()
    m.Lock()
    fmt.Println(count)
    m.Unlock()
}

此代码使用互斥体m来确保只有单个Goroutine可以同时访问count

Buat Goroutine dalam Go Contoh kod:

package main

import (
    "fmt"
    "log"
    "net/http"
)

func main() {
    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        go func() { fmt.Fprintf(w, "Hello, %s!", r.URL.Path[1:]) }()
    })
    log.Fatal(http.ListenAndServe(":8080", nil))
}

Kod ini mencipta Goroutine yang mencetak Hello dari goroutine manakala Goroutine utama mencetak Hello from main.

Saluran digunakan untuk komunikasi

Saluran paip ialah mekanisme komunikasi antara Goroutines. Ia serupa dengan baris gilir penimbal dan Goroutines boleh menggunakannya untuk menghantar dan menerima mesej.

Contoh kod untuk membuat saluran:

rrreee

Kod ini mencipta paip c, Goroutine menghantar nilai 10 ke saluran dan Goroutine utama menerima nilai daripada saluran dan mencetaknya.

Penyegerakan dan Penantian🎜🎜Dalam pengaturcaraan serentak, penyegerakan adalah penting untuk memastikan pelaksanaan yang diselaraskan antara Goroutines. Go menyediakan pelbagai primitif penyegerakan seperti mutex, pembolehubah keadaan dan kumpulan tunggu. 🎜🎜Gunakan mutex untuk melindungi kod sampel data kongsi: 🎜rrreee🎜Kod ini menggunakan mutex m untuk memastikan bahawa hanya satu Goroutine boleh mengakses pembolehubah count pada masa yang sama. 🎜🎜Kes praktikal: Pemprosesan serentak perkhidmatan web🎜🎜Menggunakan ciri serentak Go, kami boleh mencipta perkhidmatan web yang cekap yang boleh mengendalikan berbilang permintaan pada masa yang sama. 🎜🎜Kod sampel ini menunjukkan pelayan web ringkas menggunakan Goroutine untuk mengendalikan permintaan masuk: 🎜rrreee🎜Pelayan ini menggunakan Goroutine untuk mengendalikan setiap permintaan masuk secara serentak, meningkatkan kebolehskalaan dan responsif. 🎜🎜Kesimpulan🎜🎜Keupayaan pengaturcaraan serentak Go membolehkan pembangun mencipta aplikasi berprestasi tinggi, responsif dan berskala. Dengan menguasai Goroutines, saluran paip, penyegerakan dan kumpulan tunggu, kami boleh memanfaatkan sepenuhnya pemprosesan selari. 🎜

Atas ialah kandungan terperinci Panduan Pengaturcaraan Golang Concurrency: Meneroka Misteri Pemprosesan Selari. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!

Kenyataan:
Kandungan artikel ini disumbangkan secara sukarela oleh netizen, dan hak cipta adalah milik pengarang asal. Laman web ini tidak memikul tanggungjawab undang-undang yang sepadan. Jika anda menemui sebarang kandungan yang disyaki plagiarisme atau pelanggaran, sila hubungi admin@php.cn