Apakah prestasi model konkurensi dalam bahasa Go?

Dalam beberapa tahun kebelakangan ini, model konkurensi bahasa Go telah menjadi semakin popular dalam kalangan pembangun. Berbanding dengan model konkurensi bahasa lain, Goroutine dan Saluran yang digunakan dalam Go adalah lebih ringan dan lebih mudah digunakan. Jadi, dalam senario aplikasi sebenar, apakah jenis prestasi yang dimiliki oleh model konkurensi bahasa Go?

Model konkurensi bahasa Go mengguna pakai konsep reka bentuk Goroutine dan Channel, bertujuan untuk meningkatkan kecekapan operasi serentak. Goroutine boleh dianggap sebagai benang ringan, dan kos permulaan dan pemusnahannya jauh lebih rendah daripada benang tradisional. Saluran boleh dianggap sebagai "talian paip" untuk komunikasi antara Goroutines, yang bertanggungjawab untuk menghantar data. Berbanding dengan mekanisme kunci, Saluran lebih cekap dalam mencapai penyegerakan dan pengecualian bersama antara coroutine.

Dalam senario di mana jumlah tugasan serentak adalah kecil, prestasi model serentak Go tidak jelas. Walau bagaimanapun, model konkurensi Go berprestasi baik dalam senario seperti pengkomputeran selari berskala besar dan operasi I/O. Dalam senario ini, prestasi model konkurensi Go bahkan boleh mengatasi program berbilang benang tradisional.

Mengambil aplikasi intensif pengkomputeran sebagai contoh, bandingkan prestasi model konkurensi Go dan berbilang benang Python. Dalam senario aplikasi ini, adalah dijangka bahawa bilangan tugas serentak akan menjadi besar, keamatan pengkomputeran akan tinggi, dan keperluan pengkomputeran akan agak tinggi Anda boleh melaksanakan kes ujian dalam dua bahasa untuk melihat prestasinya.

Yang pertama ialah pelaksanaan Python multi-threading:

import threading

NUM_THREADS = 1000
NUM_STEPS = 1000000

def calculate_pi(start, end, step):
    pi = 0
    for i in range(start, end):
        x = (i + 0.5) * step
        pi += 4.0 / (1.0 + x * x)
    return pi

threads = []

for i in range(NUM_THREADS):
    start = int(i * NUM_STEPS / NUM_THREADS)
    end = int((i+1) * NUM_STEPS / NUM_THREADS)
    thread = threading.Thread(target=calculate_pi, args=(start, end, 1/NUM_STEPS))
    threads.append(thread)

for thread in threads:
    thread.start()

for thread in threads:
    thread.join()

Python multi-threading digunakan di sini dan 1000 threads didayakan untuk pengiraan. Keputusan ujian menunjukkan bahawa program mengambil masa kira-kira 71 saat untuk dijalankan.

Seterusnya ialah cara model konkurensi Go dilaksanakan:

package main

import (
    "sync"
)

const (
    numThreads = 1000
    numSteps = 1000000
)

func calculatePi(start int, end int, step float64, wg *sync.WaitGroup, ch chan float64) {
    pi := 0.0
    for i := start; i < end; i++ {
        x := (float64(i) + 0.5) * step
        pi += 4.0 / (1.0 + x * x)
    }
    ch <- pi
    wg.Done()
}

func main() {
    wg := &sync.WaitGroup{}
    ch := make(chan float64, numThreads)

    for i := 0; i < numThreads; i++ {
        start := int(float64(i) * float64(numSteps) / float64(numThreads))
        end := int(float64(i+1) * float64(numSteps) / float64(numThreads))
        wg.Add(1)
        go calculatePi(start, end, 1.0/float64(numSteps), wg, ch)
    }

    wg.Wait()
    close(ch)

    pi := 0.0
    for result := range ch {
        pi += result
    }

    pi *= 1.0 / float64(numSteps)

    fmt.Println(pi)
}

Keputusan ujian menunjukkan bahawa masa berjalan program ini adalah kira-kira 17 saat. Berbanding dengan Python multi-threading, model Go concurrency adalah jauh lebih cekap.

Sudah tentu, model konkurensi bahasa Go juga mempunyai beberapa had. Sebagai contoh, dalam senario intensif CPU, disebabkan oleh mekanisme kerjasama Goroutine, GOMAXPROCS (iaitu, bilangan teras CPU) mungkin tidak cukup diduduki, menjejaskan prestasi program. Tetapi secara amnya, dalam senario seperti pengkomputeran selari berskala besar dan operasi I/O, model konkurensi bahasa Go berprestasi sangat baik dan boleh meningkatkan kecekapan dan prestasi program dengan ketara.

Ringkasnya, dengan mengambil kira kesan penggunaan dalam senario aplikasi sebenar dan kemudahan operasi pembangun, model Go concurrency sudah pasti merupakan model concurrency yang lebih baik pada masa ini.

Atas ialah kandungan terperinci Apakah prestasi model konkurensi dalam bahasa Go?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!