Comparison of coroutines between Golang and JavaScript

Question: What are the differences between coroutines in Go and JavaScript? Answer: Stack: Go coroutine has its own stack, and JavaScript saves the state of the coroutine in a Promise object. Scheduling: Go coroutines are managed by the Goroutine scheduler, and JavaScript coroutines are managed by the JavaScript engine. Communication: Go coroutines communicate through channels, and JavaScript coroutines communicate through Promise. Exception handling: Go coroutine exceptions are handled by panicked and recovered, and JavaScript coroutine exceptions are handled by try/catch.

Comparison of coroutines between Golang and JavaScript

Coroutines are a user-level thread and a more lightweight concurrency mechanism than traditional threads. . Coroutines are widely used in both Go and JavaScript. This article will compare coroutines in Go and JavaScript, explore their similarities and differences, and how to use them in real projects.

Coroutines in Go

The Go language has built-in support for coroutines (called goroutines). Goroutine is a lightweight thread created by the go keyword. It is similar to a traditional thread and has its own stack and execution context. Goroutines can run concurrently without waiting for I/O operations to complete, thus improving program parallelism.

Creating coroutines:

go func() {
    // 协程代码
}

Coroutines in JavaScript

JavaScript introduces async/await syntax sugar to implement Coroutines. async The function returns a Promise object, representing the result of an asynchronous operation. The await keyword can pause the execution of the async function until the Promise object is resolved. During this time, the engine can execute other coroutines.

Create coroutine:

async function myFunction() {
    // 协程代码
}

Compare

Assume we have A program that needs to handle multiple tasks in parallel. We use goroutine to achieve concurrency:

package main

import (
    "fmt"
    "runtime"
    "time"
)

func main() {
    // 创建 10 个协程
    for i := 0; i < 10; i++ {
        go func(i int) {
            // 模拟 I/O 操作
            time.Sleep(time.Second)
            fmt.Println("协程", i, "完成")
        }(i)
    }

    // 等待所有协程完成
    runtime.Gosched()
}

In JavaScript, we use

to achieve something like Features:

async function main() {
    // 创建 10 个协程
    const promises = [];
    for (let i = 0; i < 10; i++) {
        promises.push(async function() {
            // 模拟 I/O 操作
            await sleep(1000);
            console.log("协程", i, "完成");
        });
    }

    // 等待所有协程完成
    await Promise.all(promises);
}

function sleep(ms) {
    return new Promise(resolve => setTimeout(resolve, ms));
}

main();