Aplikasi fungsi Golang pengaturcaraan serentak dalam projek besar

Pengaturcaraan serentak boleh meningkatkan prestasi dan kebolehskalaan dalam projek Go yang besar. 1. Nilai asal selaras: goroutine ialah benang ringan dan saluran ialah penimbal untuk memindahkan data dengan selamat. 2. Mod konkurensi: Konkurensi saluran paip digunakan dalam model pengeluar-pengguna; kumpulan kerja mengekalkan bilangan goroutin yang tetap, menunggu untuk melaksanakan kerja. 3. Kes praktikal: Perkhidmatan akhir e-dagang menggunakan saluran paip untuk memproses pesanan secara serentak, dan menggunakan kumpulan kerja untuk mengoptimumkan sambungan pangkalan data.

Aplikasi Pengaturcaraan Serentak Berfungsi Go dalam Projek Besar

Gambaran Keseluruhan

Dalam projek Go yang besar, memanfaatkan sepenuhnya pengaturcaraan serentak boleh meningkatkan prestasi dan kebolehskalaan dengan ketara. Mekanisme konkurensi terbina dalam Go menyediakan alat yang berkuasa untuk menulis kod selari yang cekap.

Concurrency primitives

goroutines ialah utas ringan dalam Go yang boleh melaksanakan kod tanpa mengunci keseluruhan proses. Untuk mencipta goroutine, gunakan kata kunci go:

go func() {
    // 并发执行的代码
}

saluran ialah penimbal yang digunakan untuk menghantar data dengan selamat antara goroutin. Saluran mempunyai jenis untuk memastikan keselamatan jenis data:

var dataChannel chan int
func main() {
    dataChannel = make(chan int)
    go sendData(dataChannel)
    receivedData := <-dataChannel
    fmt.Println("Received data:", receivedData)
}

func sendData(ch chan int) {
    ch <- 42 // 发送数据
}

Mod Concurrency

Concurrency saluran paip Gunakan paip untuk menghantar data dari satu goroutine ke yang lain, dengan itu melaksanakan model pengeluar dan pengguna dalam perancangan:

func pipeExample() {
    numJobs := 1000

    input := make(chan int)
    processed := make(chan int)

    // 启动一个 goroutine 表示消费者
    go func() {
        for {
            select {
            case job := <-input:
                processedData := process(job)
                processed <- processedData
            }
        }
    }()

    // 启动多个 goroutine 表示生产者
    for i := 0; i < numJobs; i++ {
        go func(i int) {
            input <- i
        }(i)
    }

    close(input) // 当所有工作都完成时关闭输入通道

    // 等待所有工作处理完成
    for i := 0; i < numJobs; i++ {
        _ = <-processed
    }
}

Kumpulan kerja bilangan goroutin tetap yang sedang menunggu kerja untuk dilaksanakan:

func workerPoolExample() {
    jobs := make(chan int)
    results := make(chan int)

    // 启动一个 goroutine 表示工作池中的每一个 worker
    for w := 1; w <= numWorkers; w++ {
        go worker(jobs, results)
    }

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

    for a := 1; a <= numJobs; a++ {
        _ = <-results // 等待接收所有结果
    }
}

func worker(jobs <-chan int, results chan<- int) {
    for j := range jobs {
        result := process(j)
        results <- result
    }
}

Menggunakan saluran paip concurrency

Groutine pengeluar
• yang mendapat pesanan daripada REST API. Satu set
Gorouti pengguna
• dapatkan pesanan daripada saluran paip, sahkan pesanan dan simpannya dalam pangkalan data.

Perkhidmatan ini juga menggunakan kumpulan kerja untuk mengoptimumkan sambungan pangkalan data:

• Setiap kali sambungan pangkalan data diperlukan, perkhidmatan mendapat sambungan daripada kumpulan pekerja dan mengembalikannya kepada goroutine pengguna.
• Selepas selesai digunakan, goroutine pengguna mengembalikan sambungan ke kumpulan pekerja.
• Dengan menggabungkan concurrency saluran paip dan kumpulan pekerja, perkhidmatan ini dapat memproses berbilang pesanan masuk dengan cekap secara serentak dan mengoptimumkan penggunaan sumber pangkalan data.

Atas ialah kandungan terperinci Aplikasi fungsi Golang pengaturcaraan serentak dalam projek besar. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!