Bagaimana fungsi golang berkomunikasi dengan goroutine

Fungsi dan Goroutine boleh berkomunikasi dengan cara berikut: Kunci Mutex: digunakan untuk melindungi sumber dikongsi Pembolehubah keadaan: digunakan untuk memberitahu Goroutine yang memenuhi syarat Saluran: penimbal pemindahan data Pembolehubah atom: pembolehubah akses serentak tanpa kunci Kes praktikal: pemprosesan selari Tugasan gunakan Goroutine untuk meningkatkan kecekapan pelaksanaan tugas intensif pengkomputeran, yang merangkumi tiga langkah: mencipta tugas, memulakan tugas pemprosesan Goroutine dan mengumpul hasil pemprosesan.

Kaedah komunikasi antara fungsi dan Goroutine dalam bahasa Go

Dalam bahasa Go, fungsi dan Goroutines boleh berkomunikasi dengan cara berikut:

1 Mutex (Mutex)

melindungi sumber yang dikongsi dan memastikan bahawa hanya satu Goroutine boleh mengakses sumber pada masa yang sama.

var mu sync.Mutex // 全局互斥锁

func increment(i *int) {
    mu.Lock()
    *i++
    mu.Unlock()
}

2. Pembolehubah keadaan (Cond)

Pembolehubah keadaan digunakan untuk memberitahu Goroutine yang menunggu apabila syarat yang ditetapkan dipenuhi.

var cond sync.Cond // 全局条件变量

func wait(c *sync.Cond, i *int) {
    c.L.Lock()
    for {
        if *i == 0 {
            c.Wait()
        }
        break
    }
    c.L.Unlock()
}

3 Saluran

Saluran ialah penimbal yang digunakan untuk menghantar data antara Goroutines.

var ch = make(chan int, 10) // 创建容量为 10 的通道

func send(c chan int, i int) {
    c <- i // 发送数据
}

func receive(c chan int) {
    v := <-c // 接收数据
}

4. Pembolehubah atom

Pembolehubah atom boleh diakses secara serentak tanpa kunci.

var atomicInt int64

func incrementAtomic(i *int64) {
    atomicInt++
}

Kes Praktikal: Tugasan Pemprosesan Selari

Berikut ialah kes praktikal menggunakan Goroutine untuk memproses tugas secara selari:

// 任务类型
type Task struct {
    Num  int
    Chan chan int
}

func processTask(t *Task) {
    // 处理任务并返回结果
    result := t.Num * t.Num
    t.Chan <- result
}

func createTasks(n int) []*Task {
    // 创建 n 个任务
    tasks := make([]*Task, n)
    for i := 0; i < n; i++ {
        tasks[i] = &Task{
            Num:  i,
            Chan: make(chan int),
        }
    }
    return tasks
}

func main() {
    n := 10
    tasks := createTasks(n)

    // 启动 n 个 Goroutine 并行处理任务
    for _, t := range tasks {
        go processTask(t)
    }

    // 从任务中收集处理结果
    results := make([]int, n)
    for i := 0; i < n; i++ {
        results[i] = <-tasks[i].Chan
    }

    // 打印结果
    for _, r := range results {
        fmt.Println(r)
    }
}

Menggunakan Goroutine untuk memproses tugas secara selari boleh meningkatkan dengan ketara pelaksanaan program, terutamanya untuk kecekapan program tugasan intensif pengiraan. 🎜

Atas ialah kandungan terperinci Bagaimana fungsi golang berkomunikasi dengan goroutine. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!