Golang coroutines and Unix-like system programming

Golang coroutine is a concurrent execution mechanism created through the goroutine keyword and used for Unix-like system programming. It implements inter-coroutine communication through channels and can be used in concurrent web servers to improve performance and scalability in practice.

Golang coroutines and Unix-like system programming

Introduction

Coroutines are a lightweight concurrent execution mechanism that can Greatly improve application performance, especially when dealing with high-concurrency, IO-intensive tasks. The Golang language provides powerful coroutine support, making it ideal for programming Unix-like systems.

Coroutine creation and management

In Golang, you can use the goroutine keyword to create a coroutine:

package main

import (
    "fmt"
    "runtime"
)

func main() {
    go func() {
        fmt.Println("这是另一个协程！")
    }()
    runtime.Gosched() // 主动让出 CPU 给其他协程
}

The above code creates a coroutine , the coroutine is executed outside the main function and prints a message. runtime.Gosched() The function actively releases CPU resources and allows other coroutines to run.

Channel communication

Channel is the mechanism used for communication between coroutines in Golang. They are a type-safe, non-blocking communication method:

package main

import (
    "fmt"
    "time"
)

func main() {
    // 创建一个有缓冲的通道，存放整数
    ch := make(chan int, 10)

    // 在一个协程中向通道发送数据
    go func() {
        for i := 0; i < 10; i++ {
            ch <- i
            time.Sleep(100 * time.Millisecond) // 延迟发送数据
        }
        close(ch) // 关闭通道，表示不再发送数据
    }()

    // 在另一个协程中从通道读取数据
    go func() {
        for {
            v, ok := <-ch
            if !ok {
                break // 通道已关闭
            }
            fmt.Println(v)
        }
    }()

    time.Sleep(1100 * time.Millisecond) // 等待协程执行完毕
}

Practical case: Concurrent Web server

Consider the example of a concurrent Web server for handling client requests:

package main

import (
    "fmt"
    "net/http"
)

func main() {
    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        fmt.Fprintf(w, "Hello, World!\n")
    })

    // 使用 Goroutine 同时监听多个端口
    go http.ListenAndServe(":8080", nil)
    go http.ListenAndServe(":8081", nil)

    select {} // 阻塞主协程，保持服务器运行
}

By using coroutines, this server can handle requests on multiple ports simultaneously, improving scalability and performance.

The above is the detailed content of Golang coroutines and Unix-like system programming. For more information, please follow other related articles on the PHP Chinese website!