Golang implements concurrency

With the continuous advancement of computer technology, the operating efficiency and performance of modern programs have become increasingly important issues. Concurrent programming is an important way to improve program running efficiency and performance. As an emerging programming language, golang's unique goroutine and channel mechanisms make concurrent programming simpler and more efficient.

This article will introduce the basic concepts of golang concurrent programming, and use some examples to show how to use goroutines and channels to build efficient concurrent programs.

1. What is goroutine

Goroutine is a lightweight thread in golang. The size of each goroutine is only about 2KB, occupying very little memory and resources. Moreover, golang's scheduler will automatically allocate goroutines to different physical threads for execution to achieve concurrent execution.

You can start a goroutine through the go keyword, for example:

package main

import (
    "fmt"
    "time"
)

func printNums() {
    for i := 0; i < 5; i++ {
        fmt.Println(i)
        time.Sleep(time.Millisecond * 500)
    }
}

func main() {
    // 启动一个goroutine
    go printNums()

    // 继续执行主goroutine
    for i := 0; i < 5; i++ {
        fmt.Println("Hello")
        time.Sleep(time.Millisecond * 500)
    }
}

Run the above program, you can see that the two goroutines alternately output numbers and Hello, thus achieving concurrent execution.

2. What is a channel

The channel in Golang is a data structure used for communication and synchronization between goroutines. Channels can transfer data between multiple goroutines and achieve secure exchange of data through the synchronization mechanism of the channel. There are two types of channels: buffered and unbuffered. Send and receive operations on unbuffered channels block until corresponding receive and send operations occur. Buffered channels can alleviate the time difference between send and receive operations to a certain extent.

Here is an example of using a buffered channel:

package main

import (
    "fmt"
    "time"
)

func main() {
    // 创建一个大小为2的带缓冲通道
    ch := make(chan string, 2)

    // 启动两个goroutine
    go func() {
        ch <- "Hello"
        ch <- "World"
    }()
    go func() {
        time.Sleep(time.Second)
        fmt.Println(<-ch)
        fmt.Println(<-ch)
    }()

    // 等待goroutine执行完毕
    time.Sleep(time.Second * 2)
}

In the above example, we create a buffered channel of size 2. Then two goroutines are started, one sends two strings to the channel, and the other receives the two strings from the channel and prints the output. Due to the existence of the buffer, there is a certain time difference between the send and receive operations, but data can still be transferred and synchronized through the channel.

In addition to buffered channels, golang also supports unbuffered channels, which can more strictly guarantee synchronization between goroutines.

3. How to use goroutine and channel to achieve concurrency

Through the previous introduction, we can see that goroutine and channel are very useful concurrent programming tools in golang. Below we will introduce some examples of how to use them to implement concurrent programming.

1. Download multiple web pages concurrently

Through goroutine and channel, we can easily download multiple web pages concurrently. For example:

package main

import (
    "fmt"
    "io/ioutil"
    "net/http"
    "time"
)

// 下载网页的函数
func download(url string, ch chan<- string) {
    resp, err := http.Get(url)
    if err != nil {
        ch <- fmt.Sprintf("%s error: %v", url, err)
        return
    }
    defer resp.Body.Close()
    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        ch <- fmt.Sprintf("%s error: %v", url, err)
        return
    }
    ch <- fmt.Sprintf("%s=%d", url, len(body))
}

func main() {
    // 要下载的网页列表
    urls := []string{
        "https://www.baidu.com",
        "https://www.google.com",
        "https://www.github.com",
    }

    // 创建一个无缓冲通道
    ch := make(chan string)

    // 启动多个goroutine下载网页
    for _, url := range urls {
        go download(url, ch)
    }

    // 从通道中读取结果，并打印输出
    for range urls {
        fmt.Println(<-ch)
    }

    // 等待goroutine执行完毕
    time.Sleep(time.Second * 2)
}

In the above example, we defined a download function to download the web page content of the specified URL and return the result through the channel. Then we started multiple goroutines through the for loop, and each goroutine called the download function to download a web page. After the download result is returned through the channel, it is read and printed in the main goroutine. In this way, we can easily download multiple web pages concurrently and improve the operating efficiency and performance of the program.

2. Process multiple tasks concurrently

In addition to downloading web pages, we can also use goroutine and channel to process multiple tasks concurrently. For example:

package main

import (
    "fmt"
    "math/rand"
    "time"
)

func worker(id int, jobs <-chan int, results chan<- int) {
    for i := range jobs {
        fmt.Printf("worker %d start job %d
", id, i)
        time.Sleep(time.Duration(rand.Intn(3)) * time.Second)
        fmt.Printf("worker %d finish job %d
", id, i)
        results <- i * 2
    }
}

func main() {
    // 定义要处理的任务列表
    jobCount := 10
    jobs := make(chan int, jobCount)
    for i := 0; i < jobCount; i++ {
        jobs <- i
    }
    close(jobs)

    // 定义结果通道
    results := make(chan int, jobCount)

    // 启动多个goroutine处理任务
    workerCount := 3
    for i := 0; i < workerCount; i++ {
        go worker(i, jobs, results)
    }

    // 从结果通道中读取结果，并打印输出
    for j := 0; j < jobCount; j++ {
        fmt.Println(<-results)
    }

    // 等待goroutine执行完毕
    time.Sleep(time.Second * 2)
}

In the above example, we defined a worker function to simulate processing the specified task. Then we started multiple goroutines through a for loop, each goroutine read a task from the jobs channel and processed it. The processing results are returned through the results channel. Finally, all results are read from the results channel in the main goroutine and printed. In this way, we can easily process multiple tasks concurrently and improve the running efficiency and performance of the program.

4. Summary

This article introduces the basic concepts of golang concurrent programming, including the use of goroutine and channel. Through multiple examples, we show how to use goroutines and channels to build efficient concurrent programs. Compared with other programming languages, golang's concurrent programming model is more concise and efficient, which greatly improves program running efficiency and performance. However, it should be noted that writing high-quality concurrent programs is not easy. It requires an in-depth understanding and mastery of the mechanisms and principles of golang concurrent programming.

The above is the detailed content of Golang implements concurrency. For more information, please follow other related articles on the PHP Chinese website!