Kaedah menulis benang golang

Golang ialah bahasa pengaturcaraan yang cekap dan ringkas, dan sokongannya untuk model konkurensi juga unik. Mekanisme benang (Goroutine) Golang, yang direka untuk meningkatkan penggunaan CPU dan prestasi program, adalah ciri utama. Artikel ini akan memperkenalkan secara terperinci cara menulis benang Golang.

1. Pengenalan kepada mekanisme benang Golang

Benang (Goroutine) di Golang ialah coroutine yang ringan Penciptaan dan penjadualannya sangat pantas, dan ruang tindanan benang juga sangat kecil ., menduduki hanya 2KB, sangat sesuai untuk program serentak berskala besar. Mekanisme benang Golang mengguna pakai model CSP, yang menggunakan saluran untuk berinteraksi dengan data antara benang, supaya penyegerakan dan pengecualian bersama antara benang dapat direalisasikan dengan sempurna.

Mekanisme threading Golang mempunyai kelebihan berikut:

1 Pelaksanaan mudah: Penciptaan dan pemusnahan benang diuruskan secara automatik oleh sistem, mengurangkan beban pengaturcara.

2. Keselamatan sambungan benang: Mekanisme utas Golang menyampaikan data antara utas melalui saluran, memastikan keselamatan serentak utas

3 Menduduki sedikit sumber: Mekanisme utas Golang menggunakan pseudo Concurrency bermakna bahawa utas tidak akan digantung kerana menyekat benang tertentu, dengan itu menduduki sesedikit mungkin sumber.

2. Cara menggunakan utas Golang

1 Buat utas

Di Golang, sangat mudah untuk membuat utas Anda hanya perlu menambah kata kunci di hadapan daripada nama fungsi. Sebagai contoh, kod berikut mencipta utas:

package main

import (
    "fmt"
    "time"
)

func main() {
    go count(1)
    go count(2)
    time.Sleep(time.Second)
}

func count(id int) {
    for i := 1; i <= 5; i++ {
        fmt.Println("线程", id, "计数", i)
        time.Sleep(time.Second)
    }
}

Kod di atas mencipta dua utas, setiap utas dikira 5 kali dan mencetak maklumat kiraan. Jalankan kod di atas dalam fungsi utama dan keluarkan hasil berikut:

线程 2 计数 1
线程 1 计数 1
线程 2 计数 2
线程 1 计数 2
线程 1 计数 3
线程 2 计数 3
线程 1 计数 4
线程 2 计数 4
线程 2 计数 5
线程 1 计数 5

Anda boleh melihat bahawa kedua-dua utas dijalankan serentak tanpa menyekat atau masalah lain.

2. Penyegerakan benang

Dalam pengaturcaraan serentak, penyegerakan benang adalah isu yang sangat kritikal. Golang menggunakan saluran untuk penyegerakan benang dan pengecualian bersama, iaitu, untuk menyelaraskan interaksi antara utas melalui penghantaran dan penerimaan saluran. Biasanya, kita boleh menggunakan saluran buffer untuk memindahkan data antara benang.

Kod berikut menunjukkan contoh penyegerakan utas 1 dan utas 2 masing-masing memulakan pembolehubah integer x Setelah pengumpulan selesai, hasilnya dihantar ke saluran xChan . Benang 2 mendarabkan hasil dengan 2 selepas menerimanya, dan menghantar hasilnya ke utas utama melalui saluran yChan. Selepas utas utama menerima hasil daripada Thread 2, ia mencetak hasil:

package main

import (
    "fmt"
    "sync"
)

func main() {
    var x int
    xChan := make(chan int, 1)
    yChan := make(chan int, 1)
    var wg sync.WaitGroup
    wg.Add(2)
    go func() {
        defer wg.Done()
        x = 1
        xChan <- x
    }()
    go func() {
        defer wg.Done()
        x = <-xChan
        yChan <- x * 2
    }()
    wg.Wait()
    y := <-yChan
    fmt.Println(y)
}

Menjalankan kod di atas, anda boleh mendapatkan hasil berikut:

2

Seperti yang anda lihat, Thread 2 berjaya menerima x yang dihasilkan oleh nilai Thread 1 dan mendarabkannya dengan 2 dan menghantarnya ke thread utama.

3. Perkara yang perlu diambil perhatian tentang benang Golang

Dalam proses menggunakan benang Golang, anda perlu memberi perhatian kepada perkara berikut:

1 dimusnahkan secara automatik oleh sistem yang diuruskan, tetapi apabila benang disekat atas sebab tertentu, ia akan menjejaskan prestasi keseluruhan aplikasi.

2. Walaupun mekanisme benang Golang menggunakan pseudo-concurrency, apabila jumlah concurrency sangat tinggi, sumber yang diduduki oleh thread akan menjadi sangat besar, sekali gus menjejaskan prestasi keseluruhan sistem.

3. Apabila menggunakan benang Golang, anda perlu memberi perhatian kepada penyegerakan benang dan pengecualian bersama untuk mengelakkan masalah seperti persaingan data dan kebuntuan.

4. Ringkasan

Mekanisme threading Golang mengguna pakai model CSP untuk berinteraksi dengan data antara thread melalui saluran, supaya penyegerakan dan pengecualian bersama antara thread dapat direalisasikan dengan sempurna. Apabila menggunakan benang Golang, anda perlu memberi perhatian kepada penyegerakan benang dan pengecualian bersama untuk mengelakkan masalah seperti persaingan data dan kebuntuan. Dengan menggunakan mekanisme benang Golang secara rasional, pengaturcaraan serentak yang cekap, selamat dan ringkas boleh dicapai.

Atas ialah kandungan terperinci Kaedah menulis benang golang. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!