Prinsip fungsi golang dan komunikasi saluran paip

Fungsi dan paip dalam bahasa Go digunakan bersama untuk mencapai komunikasi antara proses. Fungsi boleh menghantar paip sebagai parameter untuk menghantar atau menerima data melalui paip. Paip ialah saluran tanpa buffer yang boleh digunakan untuk menghantar dan menerima data antara goroutine dan menyokong kedua-dua paip tidak terarah dan terarah. Operator

Prinsip dan Amalan Fungsi dan Komunikasi Paip dalam Bahasa Go

Pengenalan

Fungsi dan paip ialah alat yang berkuasa untuk komunikasi antara proses (IPC) dalam bahasa Go. Artikel ini akan menyelidiki cara ia berfungsi dan memberikan contoh praktikal yang menunjukkan cara berkomunikasi menggunakannya.

Fungsi

Fungsi ialah warga kelas pertama dalam bahasa Go, yang boleh menghantar data sebagai parameter dan mengembalikan hasil. Apabila goroutine (benang ringan) memanggil fungsi, fungsi itu berjalan dalam skop goroutine. Pembolehubah dan sumber boleh dihantar antara panggilan fungsi.

func add(x, y int) int {
    return x + y
}

func main() {
    result := add(10, 20)
    fmt.Println(result) // 输出：30
}

Pipelines

Pipelines ialah saluran tanpa buffer yang digunakan untuk menghantar dan menerima data antara goroutines. Paip boleh tidak terarah atau diarahkan. Paip tidak terarah membenarkan data dihantar dalam kedua-dua arah antara dua goroutin, manakala paip terarah hanya membenarkan aliran data sehala.

// 无向管道
unbufferedChan := make(chan int)

// 有向管道
bufferedChan := make(chan int, 10) // 缓冲区大小为 10

Fungsi dan Komunikasi Paip

Fungsi dan paip boleh digunakan bersama untuk komunikasi antara proses. Dengan menghantar paip sebagai parameter fungsi, fungsi boleh menghantar atau menerima data melalui paip.

Menghantar data

Untuk menghantar data ke paip, anda boleh menggunakan operator <- (pengendali hantar). Operator <- menghantar data ke paip dan menyekat goroutine penghantaran sehingga data diterima. <- 操作符（发送运算符）。<- 操作符将数据发送到管道，并阻塞发送 goroutine，直到数据被接收。

func sendData(ch chan int) {
    ch <- 100
}

接收数据

要从管道接收数据，可以使用 <- 操作符（接收运算符）。<-

func receiveData(ch chan int) {
    data := <-ch
    fmt.Println(data) // 输出：100
}

Terima data

Untuk menerima data daripada paip, anda boleh menggunakan operator <- (receive operator). Operator <- menerima data daripada paip dan menyekat goroutine penerima sehingga data tersedia.

package main

import (
    "fmt"
    "sync"
)

func main() {
    // 创建无缓冲管道
    ch := make(chan int)
    var wg sync.WaitGroup

    // 创建 goroutine 发送数据到管道
    wg.Add(1)
    go func() {
        defer wg.Done()
        for i := 0; i < 10; i++ {
            ch <- i
        }
        close(ch) // 关闭管道，表示没有更多数据
    }()

    // 创建 goroutine 从管道接收数据
    wg.Add(1)
    go func() {
        defer wg.Done()
        for data := range ch {
            fmt.Println(data)
        }
    }()

    // 等待所有 goroutine 完成
    wg.Wait()
}

Contoh Praktikal: Pengiraan Serentak dalam Talian Paip

🎜🎜Contoh berikut menunjukkan cara menggunakan saluran paip untuk pengiraan serentak: 🎜rrreee🎜Dalam contoh ini, kami menghantar julat ke saluran paip dan kemudian dari saluran paip Receive andgorou yang lain mencetak data. Paip yang tidak ditimbal memastikan operasi hantar dan terima disegerakkan. Paip menyediakan mekanisme komunikasi antara dua goroutin, membolehkan pengiraan serentak. 🎜

Atas ialah kandungan terperinci Prinsip fungsi golang dan komunikasi saluran paip. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!