barisan pelaksanaan saluran paip golang

Ikhtisar

Golang ialah bahasa pengaturcaraan yang popular dalam industri Ia mempunyai kelebihan ringan, keselamatan serentak, GC terbina dalam, kompilasi pantas, dsb., dan digunakan secara meluas dalam pengkomputeran awan, Web. , perangkak web dan medan lain. Model konkurensi yang cekap Golang adalah salah satu sebab mengapa Golang begitu popular. Mekanisme saluran paip adalah salah satu daripada tiga kaedah komunikasi mekanisme konkurensi Golang dibahagikan kepada paip tidak terbuffer dan paip penampan.

Dalam model konkurensi Golang, saluran paip biasanya digunakan untuk melaksanakan mekanisme komunikasi antara pengeluar dan pengguna. Apabila pengeluar membanjiri data, pengguna boleh mendapatkan data daripada saluran paip dan memprosesnya. Dalam model ini, paip bertindak sebagai baris gilir. Oleh itu, mekanisme saluran paip Golang juga sesuai untuk pelaksanaan baris gilir.

Artikel ini akan memperkenalkan cara menggunakan mekanisme saluran paip Golang untuk melaksanakan baris gilir. Khususnya, kami akan menulis baris gilir penimbal yang menyokong konkurensi dan menunjukkan secara ringkas cara melaksanakan baris gilir berhad menggunakan paip tidak terpimpan.

Barisan dengan paip penimbal

Barisan dengan paip penimbal membolehkan pengeluar/pengguna masih berfungsi seperti biasa apabila kelajuan pengeluaran/penggunaan tidak konsisten. Ia mempunyai saiz yang tetap, pengeluar akan disekat apabila giliran penuh dan pengguna akan disekat apabila giliran kosong. Di Golang, kita boleh menggunakan fungsi make() untuk mencipta paip buffer.

Berikut ialah contoh pelaksanaan mudah:

package main

import "fmt"

type Queue struct {
    // 声明管道
    items chan int
    // 声明队列最大容量
    capacity int
}

func NewQueue(capacity int) *Queue {
    return &Queue{make(chan int, capacity), capacity}
}

func (q *Queue) Enqueue(item int) {
    q.items <- item
}

func (q *Queue) Dequeue() int {
    return <-q.items
}

func main() {
    q := NewQueue(3)

    q.Enqueue(1)
    q.Enqueue(2)
    q.Enqueue(3)

    fmt.Println(q.Dequeue()) // 1
    fmt.Println(q.Dequeue()) // 2
    fmt.Println(q.Dequeue()) // 3
}

Dalam kod di atas, kami menggunakan struktur untuk mewakili baris gilir, yang mengandungi paip dan kapasiti maksimum baris gilir. Fungsi NewQueue() digunakan untuk membuat baris gilir dengan kapasiti maksimum yang ditentukan. Dalam fungsi Enqueue(), kami menulis data ke paip dan menyekat jika paip penuh. Dalam fungsi Dequeue(), kita membaca data daripada paip dan menyekat jika paip itu kosong. Dalam fungsi main(), kami mencipta baris gilir dengan kapasiti maksimum 3 dan menambah tiga elemen 1, 2, dan 3 pada baris gilir. Kemudian, fungsi Dequeue() dipanggil dalam urutan untuk mendapatkan elemen daripada baris gilir dan mengeluarkannya ke konsol.

Paip tidak penimbal untuk melaksanakan baris gilir bersempadan

Di Golang, menggunakan paip tidak penimbal untuk melaksanakan baris gilir bersempadan memerlukan penggunaan mekanisme pernyataan pilih. Kita boleh menggunakan pernyataan lalai dalam pernyataan pilih untuk mengendalikan situasi penyekatan apabila baris gilir penuh atau kosong.

Berikut ialah contoh menggunakan paip tidak buffer untuk melaksanakan baris gilir terhad:

package main

import (
    "fmt"
    "math/rand"
)

type Queue struct {
    items chan int
}

func NewQueue() *Queue {
    return &Queue{make(chan int)}
}

func (q *Queue) Enqueue(item int) {
    select {
    case q.items <- item:
    default:
        <-q.items
        q.items <- item
    }
}

func (q *Queue) Dequeue() int {
    select {
    case item := <-q.items:
        return item
    default:
        return -1
    }
}

func main() {
    q := NewQueue()

    for i := 0; i < 10; i++ {
        go func() {
            q.Enqueue(rand.Intn(100))
        }()

        go func() {
            fmt.Println(q.Dequeue())
        }()
    }
}

Dalam kod di atas, kami juga menggunakan struktur untuk mewakili baris gilir terikat. Tidak seperti paip penimbal, kami tidak melepasi kapasiti maksimum baris gilir semasa membuat paip. Dalam fungsi Enqueue(), kami menggunakan penyataan pilih untuk memasukkan elemen apabila paip tidak penuh, kami menggunakan keadaan lalai, yang mula-mula mengeluarkan elemen pertama dalam baris gilir semasa daripada paip, dan kemudian menambah Elemen baharu dimasukkan. Fungsi Dequeue() juga menggunakan penyataan pilih untuk mengembalikan elemen pertama dalam baris gilir apabila paip tidak kosong jika paip kosong, lalai digunakan dan -1 dikembalikan.

Dalam fungsi main(), kami memasukkan 10 elemen ke dalam baris gilir dan menggunakan 10 coroutine untuk menyah gilir elemen dalam baris gilir. Kita dapat melihat bahawa kerana kapasiti baris gilir ialah 1, fungsi Enqueue() secara berterusan memasukkan elemen ke dalam baris gilir, manakala fungsi Dequeue() secara berterusan mengalih keluar elemen apabila baris gilir tidak kosong. Oleh itu, output ialah satu siri integer rawak.

Kesimpulan

Melalui pengenalan artikel ini, kita dapat melihat bahawa sangat mudah untuk melaksanakan baris gilir menggunakan mekanisme saluran paip Golang. Baris gilir dengan paip penimbal boleh secara langsung menentukan kapasiti maksimumnya dalam fungsi make(), manakala paip tidak buffer perlu menggunakan mekanisme penyataan pilih untuk melaksanakan baris gilir terikat. Disebabkan kelebihan model konkurensi Golang, adalah paling berkesan untuk menggunakan mekanisme saluran paip Golang untuk melaksanakan baris gilir.

Atas ialah kandungan terperinci barisan pelaksanaan saluran paip golang. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!