Perkongsian teknologi pelaksanaan kolam coroutine fungsi Golang

Golang, sebagai bahasa pembangunan yang pesat dan konkurensi tinggi, sememangnya mempunyai pelaksanaan kumpulan coroutine. Kumpulan coroutine ialah struktur data yang digunakan untuk mengurus coroutine Ia boleh mengehadkan jumlah bilangan coroutine dan mengawal masa penciptaan dan pemusnahannya, dengan itu mengoptimumkan penggunaan sumber dalam persekitaran serentak. Seterusnya, saya akan memperkenalkan cara menggunakan fungsi Golang untuk melaksanakan kumpulan coroutine.

1. Konsep kumpulan coroutine

Kolam coroutine ialah struktur data yang digunakan untuk mengurus coroutine untuk mengehadkan bilangan coroutine dan mengawal penciptaannya dan Masa kemusnahan, dengan itu menambah baik keselarasan program.

Dalam kes konkurensi yang tinggi, memulakan coroutine akan menghasilkan banyak overhed setiap kali. Jika program perlu membuka ratusan atau beribu-ribu coroutine pada masa yang sama, overhed ini akan menjadi sangat ketara. Sama seperti kumpulan sambungan biasa dan kumpulan benang, kumpulan coroutine boleh menggunakan sumber komputer dengan lebih baik dan menyelesaikan tugas yang melibatkan sejumlah besar operasi serentak.

2. Idea pelaksanaan kumpulan coroutine

Kolam coroutine boleh dibahagikan kepada kumpulan berskala dan kumpulan tetap. Antaranya, kolam boleh skala secara automatik boleh mengembang dan mengecilkan kapasiti mengikut permintaan, manakala kolam tetap mempunyai kapasiti tetap pada permulaan dan tidak boleh diubah.

Idea utama fungsi Golang untuk melaksanakan kumpulan coroutine adalah untuk berkomunikasi melalui dua saluran. Satu ialah workerChannel, yang digunakan untuk menetapkan tugas kepada pekerja coroutine, dan satu lagi ialah saluran tugas, yang digunakan untuk menghantar tugas kepada workerChannel. Apabila terdapat tugas yang perlu dilaksanakan, tugas itu dikeluarkan daripada saluran tugas dan coroutine dibuat berdasarkan bilangan pekerja yang tersedia dalam workerChannel atau tugasan itu diberikan terus kepada pekerja terbiar untuk dilaksanakan. Pekerja yang menyelesaikan tugas akan kembali ke workerChannel dan menunggu tugasan seterusnya. Sudah tentu, dalam beberapa kes, kumpulan coroutine juga boleh mengandungi lebih banyak struktur data, seperti mutex atau kumpulan menunggu, untuk mengawal cara tugasan dilaksanakan.

3. Kod pelaksanaan kumpulan coroutine

Berikut ialah kod khusus untuk melaksanakan kumpulan coroutine:

package main

import (
    "fmt"
    "sync"
)

type Task struct {
    f func() error
}

var wg sync.WaitGroup

type Pool struct {
    //任务通道
    JobQueue chan Task
    //worker通道
    WorkerQueue chan chan Task
    //worker数量
    MaxWorkers int
}

func NewPool(maxWorkers int) *Pool {
    return &Pool{
        JobQueue:    make(chan Task, 10),
        WorkerQueue: make(chan chan Task, maxWorkers),
        MaxWorkers:  maxWorkers,
    }
}

func (p *Pool) Run() {
    for i := 0; i < p.MaxWorkers; i++ {
        worker := NewWorker(i+1, p.WorkerQueue)
        worker.Start()
    }

    go p.dispatch()
}

func (p *Pool) dispatch() {
    for {
        select {
        case job := <-p.JobQueue:
            fmt.Println("new job")
            worker := <-p.WorkerQueue
            fmt.Println("append job")
            worker <- job
            fmt.Println("after run job")
        }
    }
}

func (p *Pool) AddTask(task Task) {
    p.JobQueue <- task
}

type Worker struct {
    id          int
    WorkerQueue chan chan Task
    JobChannel  chan Task
    quitChan    chan struct{}
}

func NewWorker(id int, workerQueue chan chan Task) Worker {
    fmt.Println("newWorker")
    return Worker{
        id:          id,
        WorkerQueue: workerQueue,
        JobChannel:  make(chan Task),
        quitChan:    make(chan struct{}),
    }
}

func (w *Worker) Start() {
    fmt.Println("worker start")
    go func() {
        for {
            //将自己的jobChannel放入worker队列中
            w.WorkerQueue <- w.JobChannel
            select {
            case task := <-w.JobChannel:
                fmt.Printf("worker%d start job
", w.id)
                task.f()
                fmt.Printf("worker%d finished job
", w.id)
            case <-w.quitChan:
                fmt.Printf("worker%d quit
", w.id)
                return
            }
        }
    }()
}

func (w *Worker) Stop() {
    go func() {
        w.quitChan <- struct{}{}
    }()
}

func Hello() error {
    fmt.Println("Hello World")
    wg.Done()
    return nil
}

func main() {
    p := NewPool(5)
    p.Run()

    for i := 0; i < 100; i++ {
        task := Task{
            f: Hello,
        }
        wg.Add(1)
        p.AddTask(task)
    }
    wg.Wait()
}

Dengan menjalankan kod di atas, anda boleh melihat kawalan Keluaran maklumat log oleh stesen. Antaranya, worker start bermaksud setiap pekerja mula berjalan, new job bermaksud menambah task pada task channel, append job bermaksud tugasan diletakkan dalam worker channel dan menunggu pelaksanaan, dan selepas run job bermakna tugasan telah selesai. berjaya dilaksanakan.

4. Analisis Kod

Dalam kod di atas, fungsi NewPool digunakan untuk memulakan kumpulan coroutine, yang merangkumi saluran tugas, saluran pekerja dan bilangan pekerja. Jenis Pekerja sepadan dengan pekerja coroutine dan termasuk saluran tugas dan saluran berhenti untuk menamatkan perjalanan coroutine pekerja. Fungsi NewWorker bertanggungjawab untuk memulakan objek pekerja dan menambah saluran tugasnya ke saluran pekerja dalam kumpulan coroutine.

Fungsi AddTask digunakan untuk menambah tugasan baharu pada saluran tugas kumpulan coroutine. Fungsi ini menyekat sehingga tugasan ditambahkan. Sekiranya terdapat pekerja percuma dalam saluran pekerja, tugas itu akan diberikan kepada pekerja secara langsung, jika tidak, ia akan menunggu pekerja dalam saluran pekerja dilepaskan.

Fungsi Mula bertanggungjawab untuk memulakan coroutine pekerja dan mula menunggu ketibaan tugas. Fungsi ini mula-mula akan menambah saluran tugasnya sendiri pada saluran pekerja, dan kemudian tunggu tugasan tiba sehingga saluran tugas ditutup atau isyarat saluran keluar diterima. Jika tugasan diterima, laksanakan tugas itu. Jika isyarat saluran berhenti diterima dalam gelung, ini bermakna perjalanan coroutine perlu ditamatkan dan pekerja akan mengeluarkan dirinya daripada saluran pekerja pada masa ini.

Fungsi penghantaran ialah coroutine go yang mendengar saluran tugasan dan memberikan tugasan kepada mereka berdasarkan pekerja yang ada. Apabila terdapat tugasan baharu dalam saluran tugas, penghantaran akan cuba mendapatkan pekerja percuma daripada saluran pekerja dan menyerahkan tugas kepada mereka. Jika tiada pekerja percuma dalam saluran pekerja, ia akan menunggu sehingga pekerja dibebaskan.

5. Ringkasan

Artikel ini memperkenalkan idea dan kod pelaksanaan fungsi Golang untuk melaksanakan kumpulan coroutine. Bilangan coroutine boleh dikawal melalui kumpulan coroutine, supaya sumber komputer boleh digunakan sepenuhnya dalam persekitaran concurrency tinggi dan concurrency program boleh dipertingkatkan.

Atas ialah kandungan terperinci Perkongsian teknologi pelaksanaan kolam coroutine fungsi Golang. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!