Cara menutup benang dalam golang

Golang ialah bahasa pengaturcaraan yang agak baharu yang mempunyai fungsi serentak yang sangat berkuasa dan keupayaan pengurusan sumber. Di Golang, kami biasanya menggunakan goroutine untuk melaksanakan operasi serentak, dan benang boleh dianggap sebagai pelaksanaan peringkat rendah goroutine.

Dalam pembangunan sebenar, kami selalunya perlu menutup utas secara manual untuk melepaskan sumber sistem, dengan itu mengelakkan kebocoran sumber dan pembaziran sumber yang tidak perlu Artikel ini akan memperkenalkan cara menutup utas di Golang.

Mengapa anda perlu menutup benang?

Thread ialah sumber sistem pengendalian Setiap utas perlu menduduki sumber sistem tertentu, termasuk memori, CPU, dsb. Jika terlalu banyak utas dibuat dan tidak ditutup dalam masa, sumber sistem akan digunakan secara berlebihan, yang membawa kepada ranap sistem dan masalah lain.

Oleh itu, untuk memastikan operasi sistem yang stabil, kami perlu mengeluarkan sumber benang yang tidak perlu secara manual untuk mengelakkan daripada menduduki terlalu banyak sumber sistem Ini juga sebab untuk menutup rangkaian.

Bagaimana hendak menutup benang?

Adalah mudah untuk menutup rangkaian di Golang. Kami boleh menggunakan saluran untuk mencapai matlamat ini. Langkah-langkah khusus adalah seperti berikut:

1. Buat saluran

Mula-mula kita perlu mencipta saluran untuk komunikasi. Kami boleh mencipta saluran menggunakan kata kunci make:

ch := make(chan bool)

Di sini kami mencipta saluran Boolean yang tidak dibuffer untuk menghantar maklumat kawalan.

2. Dengar saluran dalam goroutine

Kita perlu mendengar saluran ini dalam goroutine Jika mesej yang dinyatakan diterima, keluar dari goroutine:

go func() {
    for {
        select {
        case <- ch:
            // 需要关闭的操作
            return
        default:
            // 其他操作
        }
    }
}()

Di sini kami menggunakan pernyataan pilih untuk mendengar saluran. Jika mesej daripada saluran ch diterima, operasi dalaman yang perlu ditutup dilakukan, dan kembali keluar dari goroutine semasa.

Selain itu, kami juga boleh menambah operasi lain yang perlu dilakukan dalam cawangan lalai, seperti beberapa gelung, pemasa, dsb.

3. Tutup goroutine

Akhir sekali, kami hanya perlu menghantar mesej ke saluran ini di mana goroutine perlu ditutup:

ch <- true

Di sini kami Nilai sebenar Boolean dihantar ke saluran ch Pada masa ini, goroutine memantau saluran akan menerima nilai ini, melakukan operasi yang sepadan dan keluar.

Kod Contoh

Berikut ialah kod contoh lengkap untuk menunjukkan cara menutup goroutine:

package main

import (
    "fmt"
    "time"
)

func main() {
    ch := make(chan bool)

    go func() {
        for {
            select {
            case <- ch:
                fmt.Println("关闭goroutine...")
                return
            default:
                fmt.Println("运行中...")
                time.Sleep(1 * time.Second)
            }
        }
    }()

    time.Sleep(5 * time.Second)
    ch <- true
    time.Sleep(1 * time.Second)
    fmt.Println("程序结束。")
}

Dalam kod ini, kami mula-mula mencipta saluran ch , kemudian goroutine dibuka, dan pernyataan pilih digunakan dalam goroutine untuk memantau saluran ch Apabila mesej saluran diterima, operasi penutupan yang sepadan dilakukan dan goroutine keluar.

Dalam fungsi utama, kita tidur selama 5 saat dan kemudian menghantar mesej ke saluran ch untuk menutup goroutine. Akhirnya, ia tidur selama 1 saat dan mengeluarkan maklumat akhir program.

Ringkasan

Kendalian menutup benang di Golang adalah agak mudah Anda hanya perlu mencipta saluran dan menggunakan pernyataan pilih dalam goroutine untuk mendengar saluran ini. Apabila anda perlu menutup goroutine, anda hanya perlu menghantar mesej penutupan ke saluran. Melalui pengenalan artikel ini, semua orang seharusnya dapat memahami dengan lebih baik operasi penutupan benang di Golang dan menerapkannya pada pembangunan sebenar.

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