Aplikasi penutupan fungsi golang dalam pengaturcaraan serentak

Penutupan ialah ciri dalam Go yang membenarkan fungsi mengakses pembolehubah luaran dan berguna dalam pengaturcaraan serentak. Melalui penutupan, coroutine boleh berkongsi data dan lulus nilai dengan selamat. Aplikasi penutupan biasa dalam pengaturcaraan serentak termasuk perkongsian data tanpa memerlukan mekanisme penyegerakan. Lulus nilai antara coroutine, walaupun nilai itu tidak tersedia sehingga penutupan ditutup. Batalkan coroutine dengan menyimpan saluran yang menunjukkan operasi pembatalan.

Aplikasi penutupan fungsi bahasa Go dalam pengaturcaraan serentak

Penutupan ialah ciri berkuasa dalam bahasa Go, yang membolehkan fungsi mengakses pembolehubah di luar skopnya. Mekanisme ini sangat berguna dalam pengaturcaraan serentak kerana ia membolehkan kami berkongsi data dengan selamat dan menghantar nilai antara coroutine.

Prinsip Asas

Penutupan merujuk kepada fungsi dan set semua pembolehubah dalam skop kandungannya. Dalam Go, fungsi boleh mengembalikan penunjuk kepada fungsi lain (penutupan). Penutupan ini boleh mengakses semua pembolehubah dalam skop fungsi induknya, walaupun jika fungsi induk telah kembali.

Sebagai contoh, kod berikut menunjukkan penutupan mudah:

func outer(x int) func() int {
    // x 的值在这个闭包内部可用
    return func() int {
        return x
    }
}

Fungsi outer mengembalikan penutupan yang mengakses dan mengembalikan nilai x</code pada nilai return function call code> . <code>outer 函数返回了一个闭包，该闭包访问并在返回函数调用时返回变量 x 的值。

并发编程中的应用

闭包在并发编程中非常有用，因为它允许在协程之间安全地共享和修改数据。以下是一些常见的用例：

• 共享数据：闭包可以在多个协程之间共享数据，而无需使用互斥锁或其他同步机制。
• 传值：闭包可以在协程之间传值，即使这些值在闭包闭合后才可用。
• 取消操作：闭包可以存储一个通道，该通道指示何时取消操作。这允许我们优雅地退出协程，并清理任何已分配的资源。

实战案例

考虑以下代码示例，它演示了闭包在并发编程中的使用：

package main

import (
    "fmt"
    "sync"
    "time"
)

func main() {

    // 创建一个要并发执行的任务列表
    tasks := []func(){
        func() { fmt.Println("Task 1") },
        func() { fmt.Println("Task 2") },
        func() { fmt.Println("Task 3") },
    }

    // 创建一个等待组以跟踪并发的任务
    var wg sync.WaitGroup
    wg.Add(len(tasks))

    // 创建一个通道来取消操作
    cancel := make(chan struct{})

    // 为每个任务创建一个闭包
    for _, task := range tasks {
        go func(task func()) {
            defer wg.Done()
            select {
            case <-cancel:
                // 如果收到取消信号，则退出协程
                return
            default:
                // 如果没有收到取消信号，则执行任务
                task()
            }
        }(task)
    }

    // 等待所有任务完成
    wg.Wait()
    fmt.Println("All tasks completed")

    // 发送取消信号以取消任何正在运行的协程
    close(cancel)
}

用法：

• tasks 列表包含要并发执行的任务。
• wg 跟踪并发任务的进度。
• cancel 通道用于向协程发送取消信号。
• 每个任务都通过闭包封装在自己的协程中。该闭包可以访问 cancel 通道，以便在接收到取消信号时退出。
• 主协程使用 wg.Wait() 等待所有任务完成。
• 一旦所有任务完成，主协程发送 cancel 信号以取消任何剩余的协程。

在这个示例中，闭包被用来在协程之间安全地共享 cancel

Aplikasi dalam Pengaturcaraan Serentak🎜🎜Penutupan sangat berguna dalam pengaturcaraan serentak kerana ia membenarkan data dikongsi dan diubah suai dengan selamat antara coroutine. Berikut ialah beberapa kes penggunaan biasa: 🎜

• Data kongsi: Penutupan boleh berkongsi data antara berbilang coroutine tanpa menggunakan mutex atau mekanisme penyegerakan lain.
• Melalui nilai: Penutupan boleh menghantar nilai antara coroutine, walaupun jika nilai ini tidak tersedia sehingga penutupan ditutup.
• Batalkan operasi: Penutupan boleh menyimpan saluran yang menunjukkan apabila operasi dibatalkan. Ini membolehkan kami keluar dari coroutine dengan anggun dan membersihkan sebarang sumber yang diperuntukkan.

🎜Contoh Praktikal🎜🎜Pertimbangkan contoh kod berikut, yang menunjukkan penggunaan penutupan dalam pengaturcaraan serentak: 🎜rrreee🎜Penggunaan: 🎜

• tugas mengandungi tugasan untuk dilaksanakan serentak.
• wg Menjejak kemajuan tugasan serentak.
• Saluran batal digunakan untuk menghantar isyarat pembatalan kepada coroutine.
• Setiap tugasan dirangkumkan dalam coroutine sendiri melalui penutupan. Penutupan mempunyai akses kepada saluran batal untuk keluar apabila isyarat pembatalan diterima.
• Coroutine utama menggunakan wg.Wait() untuk menunggu semua tugasan selesai.
• Setelah semua tugasan selesai, coroutine utama menghantar isyarat batal untuk membatalkan mana-mana coroutine yang tinggal.

🎜Dalam contoh ini, penutupan digunakan untuk berkongsi saluran batal dengan selamat antara coroutine, membolehkan kami membatalkan operasi apabila diperlukan. 🎜

Atas ialah kandungan terperinci Aplikasi penutupan fungsi golang dalam pengaturcaraan serentak. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!