Cara menggunakan Goroutines untuk pengurusan kumpulan sumber dalam bahasa Go

Cara menggunakan Goroutines dalam bahasa Go untuk pengurusan kumpulan sumber

Ikhtisar:
Groutines dalam bahasa Go ialah pelaksanaan urutan ringan yang membolehkan kami memproses tugasan secara serentak dengan cekap. Dalam pembangunan sebenar, kita sering perlu menguruskan beberapa sumber terhad, seperti sambungan pangkalan data, sambungan rangkaian, dll. Goroutines boleh digunakan untuk mengurus permintaan serentak dengan baik dan meningkatkan prestasi dan kecekapan sistem.

Artikel ini akan memperkenalkan cara menggunakan Goroutines dan fungsi alatnya yang sepadan untuk melaksanakan pengurusan kumpulan sumber. Kami akan menggunakan sambungan pangkalan data sebagai contoh untuk menggambarkan.

1. Tentukan struktur kumpulan sumber

Pertama, kita perlu menentukan struktur kumpulan sumber untuk mengurus sambungan pangkalan data. Takrifannya adalah seperti berikut:

type Connection struct {
    // 数据库连接
    DB *sql.DB
    // 是否正在被使用
    InUse bool
    // 互斥锁
    Mutex sync.Mutex
}

2. Memulakan kumpulan sumber

Seterusnya, kita perlu memulakan kumpulan sumber dan mencipta beberapa sambungan pangkalan data. Boleh adjust ikut keperluan. Contoh kod adalah seperti berikut:

type ResourcePool struct {
    // 最大连接数
    MaxConnections int
    // 当前使用的连接数
    CurrentConnections int
    // 资源池
    Pool []*Connection
    // 互斥锁
    Mutex sync.Mutex
    // 等待队列
    WaitQueue chan bool
}

func NewResourcePool(maxConnections int) *ResourcePool {
    pool := &ResourcePool{
        MaxConnections:     maxConnections,
        CurrentConnections: 0,
        Pool:               make([]*Connection, maxConnections),
        WaitQueue:          make(chan bool),
    }
    for i := 0; i < maxConnections; i++ {
        pool.Pool[i] = &Connection{}
    }
    return pool
}

3. Dapatkan sambungan daripada kumpulan sumber

Dalam kumpulan sumber, sambungan pangkalan data adalah terhad, dan kita perlu mengawal bilangan sambungan yang digunakan pada masa yang sama untuk mengelakkan persaingan sumber. Apabila Goroutine perlu mendapatkan sambungan, ia akan menyemak sama ada terdapat sambungan yang tersedia dalam kumpulan sambungan. Jika terdapat sambungan yang tersedia, Goroutine akan mendapatkan sambungan, jika tidak, ia akan memasuki baris gilir menunggu.

func (pool *ResourcePool) Get() *Connection {
    // 加锁
    pool.Mutex.Lock()
    defer pool.Mutex.Unlock()

    // 检查连接池
    for i := 0; i < pool.MaxConnections; i++ {
        conn := pool.Pool[i]
        if !conn.InUse {
            // 找到可用的连接
            conn.Mutex.Lock()
            conn.InUse = true
            conn.Mutex.Unlock()

            pool.CurrentConnections++
            return conn
        }
    }

    // 进入等待队列
    pool.WaitQueue <- true
    return nil
}

4. Gunakan sambungan dan kembalikan ke kolam sumber

Selepas menggunakan sambungan dalam Goroutine, kita perlu mengembalikan sambungan ke kolam sumber untuk digunakan oleh Goroutine lain. Kodnya adalah seperti berikut:

func (pool *ResourcePool) Put(conn *Connection) {
    // 加锁
    conn.Mutex.Lock()
    conn.InUse = false
    conn.Mutex.Unlock()

    // 归还到资源池
    pool.Mutex.Lock()
    pool.CurrentConnections--
    pool.Mutex.Unlock()

    // 通知等待队列
    select {
    case <-pool.WaitQueue:
        // 有等待的Goroutine，唤醒一个
        pool.Mutex.Lock()
        pool.CurrentConnections++
        pool.Mutex.Unlock()

        pool.WaitQueue <- true
    default:
        // 没有等待的Goroutine
    }
}

5. Menggunakan kumpulan sumber

Kini kita boleh menggunakan kumpulan sumber untuk menguruskan sambungan pangkalan data. Contoh kod adalah seperti berikut:

func main() {
    pool := NewResourcePool(10)
    // 创建多个Goroutine并发获取数据库连接
    for i := 0; i < 20; i++ {
        go func() {
            conn := pool.Get()
            if conn != nil {
                // 使用数据库连接进行查询等操作
                fmt.Println("Do something with database connection")
                time.Sleep(time.Second * 3)

                // 使用完毕后归还连接到资源池
                pool.Put(conn)
            }
        }()
    }
    // 等待Goroutine执行完毕
    time.Sleep(time.Second * 20)
}

Ringkasan:
Dengan menggunakan Goroutines untuk mengurus kumpulan sumber, kami boleh mengawal dan mengurus permintaan serentak dengan berkesan. Kumpulan sumber boleh digunakan pada pelbagai senario sumber terhad, seperti sambungan pangkalan data, sambungan rangkaian, dsb. Dalam pembangunan sebenar, kita boleh melaraskan saiz kumpulan sumber dan kawalan serentak mengikut keperluan kita sendiri. Saya harap artikel ini dapat membantu anda memahami dan menggunakan pengurusan kumpulan sumber.

Atas ialah kandungan terperinci Cara menggunakan Goroutines untuk pengurusan kumpulan sumber dalam bahasa Go. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!