Teknologi pemprosesan berbilang proses dan berbilang teras dalam bahasa Go

Dengan peningkatan berterusan dan pembangunan perkakasan komputer, pembangunan perisian juga sentiasa berubah daripada teras tunggal kepada berbilang teras. Dengan kemunculan teknologi pemprosesan berbilang teras, pembangun perisian secara beransur-ansur mula memberi perhatian kepada cara memproses data pada pemproses berbilang teras.

Bahasa Go ialah bahasa pengaturcaraan yang dibangunkan oleh Google Matlamat reka bentuknya ialah untuk mengendalikan prestasi serentak dan berbilang teras. Dalam bahasa Go, teknik pemprosesan berbilang proses dan berbilang teras boleh digunakan untuk menggunakan CPU berbilang teras dengan berkesan. Artikel ini akan memperkenalkan cara dan kaedah untuk melaksanakan teknologi pemprosesan berbilang proses dan berbilang teras dalam bahasa Go.

1. Pelbagai proses

Teknologi berbilang proses merujuk kepada menjalankan berbilang proses pada komputer yang sama Proses ini boleh berjalan secara selari untuk meningkatkan prestasi komputer. Dalam bahasa Go, pelbagai pemprosesan dilaksanakan dengan menggunakan goroutine.

Goroutine ialah utas ringan yang boleh dibuat dan dimusnahkan dalam timbunan masa jalan bahasa Go dan tidak perlu menduduki terlalu banyak sumber sistem seperti utas sistem pengendalian. Dalam bahasa Go, goroutine boleh dimulakan melalui kata kunci go.

Berikut ialah contoh mudah:

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

Dalam contoh ini, kami menggunakan kata kunci go untuk memulakan goroutine dan mencetak mesej dalam goroutine. Pada masa yang sama, mesej juga dicetak dalam fungsi utama.

Apabila kod ini dijalankan, "fungsi utama" dikeluarkan dahulu, dan kemudian "goroutine". Ini kerana selepas memulakan goroutine, program tidak menunggu pelaksanaan goroutine, tetapi terus melaksanakan fungsi utama.

Jika anda mahu fungsi utama menunggu pelaksanaan goroutine, anda boleh menggunakan WaitGroup dalam pakej penyegerakan. Berikut ialah contoh menggunakan WaitGroup untuk melaksanakan pelbagai kerjasama goroutine:

import (
    "fmt"
    "sync"
)

func main() {
    var wg sync.WaitGroup
    for i := 0; i < 10; i++ {
        wg.Add(1)
        go func(i int) {
            fmt.Println(i)
            wg.Done()
        }(i)
    }
    wg.Wait()
    fmt.Println("done")
}

Dalam contoh ini, kami mula-mula mencipta objek WaitGroup, dan kemudian menggunakan kaedah Tambah untuk menambah tugasan pada WaitGroup. Dalam tugasan, kami mencetak nombor goroutine dan menggunakan kaedah Selesai untuk memberitahu WaitGroup bahawa tugasan telah selesai.

Akhir sekali, kami menggunakan kaedah Tunggu untuk menunggu semua tugasan selesai sebelum keluar dari utas utama. Ini memastikan bahawa semua goroutine dilaksanakan.

2. Pemprosesan berbilang teras

Pemprosesan berbilang teras merujuk kepada menjalankan berbilang teras pada komputer yang sama, dan setiap teras boleh menjalankan satu atau lebih utas. Bahasa Go melaksanakan pemprosesan berbilang teras automatik dengan menggunakan pakej masa jalan.

Dalam bahasa Go, anda boleh menetapkan bilangan teras yang digunakan oleh program melalui pembolehubah persekitaran GOMAXPROCS. Nilai lalai GOMAXPROCS ialah bilangan teras CPU sistem.

Berikut ialah contoh pelaksanaan pemprosesan berbilang teras dalam bahasa Go:

import (
    "runtime"
)

func main() {
    runtime.GOMAXPROCS(2) // 设置使用的核心数为2
    // ...
}

Dalam contoh ini, kami menggunakan kaedah GOMAXPROCS dalam pakej masa jalan untuk menetapkan bilangan teras yang digunakan oleh program ke 2. Dalam kes ini, program secara automatik mengedarkan tugas antara dua teras.

3. Aplikasi komprehensif berbilang proses dan berbilang teras

Dalam aplikasi sebenar, pemprosesan berbilang proses dan berbilang teras biasanya digunakan pada masa yang sama. Sebagai contoh, dalam tugasan intensif pengiraan, kita boleh memulakan berbilang goroutin dan menugaskannya kepada teras yang berbeza untuk pelaksanaan bagi meningkatkan prestasi komputer.

Berikut ialah contoh:

import (
    "runtime"
    "sync"
)

const taskCount = 10

func worker(wg *sync.WaitGroup, taskCh chan int) {
    for task := range taskCh {
        // 处理任务
        runtime.Gosched() // 让出CPU时间片
        wg.Done()
    }
}

func main() {
    runtime.GOMAXPROCS(2)

    taskCh := make(chan int, taskCount)
    for i := 0; i < runtime.NumCPU(); i++ {
        go worker(&wg, taskCh)
    }

    for i := 0; i < taskCount; i++ {
        wg.Add(1)
        taskCh <- i
    }

    close(taskCh)
    wg.Wait()
    fmt.Println("done")
}

Dalam contoh ini, kami memulakan berbilang goroutin dan menetapkannya kepada teras yang berbeza untuk dilaksanakan. Pada masa yang sama, kami juga menggunakan WaitGroup dan saluran untuk bekerjasama dalam berbilang tugas.

Kesimpulan

Dengan menggunakan teknologi pemprosesan berbilang proses dan berbilang teras dalam bahasa Go, pemprosesan data yang lebih pantas dan cekap boleh dicapai. Dalam aplikasi praktikal, anda boleh memilih untuk menggunakan pelbagai proses, pemprosesan berbilang teras atau gabungan kedua-duanya mengikut sifat tugas dan konfigurasi perkakasan komputer. Dalam bahasa Go, pelaksanaan teknologi ini sangat mudah dan mudah, dan pembangun boleh dengan mudah memanfaatkan prestasi berbilang teras komputer untuk meningkatkan prestasi program.

Atas ialah kandungan terperinci Teknologi pemprosesan berbilang proses dan berbilang teras dalam bahasa Go. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!