Masa pelaksanaan fungsi golang dan goroutine

Dalam bahasa Go, fungsi yang dipanggil serentak dilaksanakan secara berurutan dalam goroutine semasa, manakala fungsi yang dipanggil secara tak segerak dilaksanakan secara selari dalam goroutine baharu melalui kata kunci go. Dengan mengawal cara fungsi dipanggil, anda boleh menyesuaikan tingkah laku serentak program dan mengoptimumkan prestasinya.

Masa pelaksanaan fungsi dan Goroutines dalam bahasa Go

Fahami model konkurensi bahasa Go

Bahasa Go mengguna pakai model Communicating Sequential and Process.Proses (CSP). Goroutine ialah utas pelaksanaan yang ringan, serupa dengan utas dalam bahasa lain, tetapi lebih cekap daripada perspektif penjadualan dan peruntukan sumber.

Masa pelaksanaan fungsi dan Goroutines

Masa pelaksanaan fungsi dan goroutin dalam bahasa Go bergantung pada cara ia dipanggil dan tempat ia dipanggil.

• Panggilan segerak: Apabila fungsi dipanggil serentak (contohnya, dipanggil terus dalam goroutine utama), ia akan dilaksanakan secara berurutan dalam goroutine semasa.
• Panggilan tak segerak: Apabila fungsi dipanggil secara tak segerak (contohnya, melalui kata kunci go dalam goroutine), ia akan dilaksanakan secara selari dalam goroutine baharu. Masa pelaksanaan goroutine ini ditentukan oleh penjadual, dan ia boleh dilaksanakan serta-merta atau pada masa yang akan datang. go 关键字调用），它将在一个新的 goroutine 中并行执行。该 goroutine 的执行时机由调度器决定，并且它可以立即执行，也可以在稍后执行。

实战案例

以下是一个比较同步调用和异步调用影响的简单示例：

package main

import (
    "fmt"
    "time"
)

func main() {
    // 同步调用
    start := time.Now()
    fmt.Println("同步调用开始")
    syncFunction()
    fmt.Println("同步调用结束", time.Since(start))

    // 异步调用
    start = time.Now()
    fmt.Println("异步调用开始")
    go asyncFunction()
    fmt.Println("异步调用结束", time.Since(start))
}

func syncFunction() {
    for i := 0; i < 100000000; i++ {
        // noop
    }
}

func asyncFunction() {
    for i := 0; i < 100000000; i++ {
        // noop
    }
}

在同步调用中，syncFunction 在当前 goroutine 中顺序执行，导致程序总共运行 2 秒左右。在异步调用中，asyncFunction 在一个新的 goroutine 中并行执行，导致程序总共运行时间不到 1 秒，因为 main 函数在 asyncFunction

Kes praktikal

Berikut ialah contoh mudah membandingkan kesan panggilan segerak dan panggilan tak segerak:

rrreee

Dalam panggilan segerak, syncFunction dilaksanakan secara berurutan semasa goroutine, mengakibatkan Program ini berjalan selama kira-kira 2 saat secara keseluruhan. Dalam panggilan tak segerak, asyncFunction dilaksanakan selari dalam goroutine baharu, menghasilkan jumlah masa berjalan program kurang daripada 1 saat kerana fungsi utama berada dalam asyncFunction Pelaksanaan diteruskan sebelum selesai. 🎜🎜🎜Kesimpulan🎜🎜🎜Memahami masa pelaksanaan fungsi dan goroutin adalah penting untuk menggunakan konkurensi secara berkesan dalam Go. Dengan mengawal cara fungsi dipanggil, anda boleh menyesuaikan tingkah laku serentak program anda dan mengoptimumkan prestasinya. 🎜

Atas ialah kandungan terperinci Masa pelaksanaan fungsi golang dan goroutine. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!