How to use Goroutines in Go?

Go language is a programming language that supports concurrency, and one of its core features is Goroutines. Goroutines are lightweight threads that allow us to create concurrent execution processes in our programs. By using Goroutines, we can easily write efficient concurrent programs. In this article, we will learn how to use Goroutines in Go.

What are Goroutines?

Goroutines are lightweight threads managed by the Go runtime. Unlike operating system threads, Goroutines are not managed by the operating system kernel, but are supported by the Go runtime. Therefore, Goroutines are more lightweight and can be created and destroyed faster than operating system threads. Goroutines are the core of Go language concurrency, enabling the ability to separate and execute function bodies concurrently.

How Goroutines are created

In Go, we can use the keyword go to create a new Goroutine. The following is a simple example:

package main

import (
    "fmt"
    "time"
)

func hello() {
    fmt.Println("Hello goroutine!")
}

func main() {
    go hello()
    time.Sleep(1 * time.Second)
    fmt.Println("main function")
}

In this example, we define a hello function, which will be executed in a new Goroutine. We create a new Goroutine using the keyword go in the main function and pass the hello function to it as a parameter. When we run the program, the hello function will run asynchronously in a new Goroutine, while the main function will continue to execute. We use the time.Sleep function to make the main function wait for 1 second to ensure that the hello function has enough time to execute.

Execution process of Goroutines

After creating Goroutines, it will execute concurrently with the main thread. Goroutines can execute other functions or codes asynchronously and concurrently. Go programs are started in a main Goroutine. When we use the keyword go to create a new Goroutine, the Go runtime will create a new lightweight thread and allocate a Goroutine stack, and then add the Goroutine to the Go runtime's scheduler. The Go runtime will select an available Goroutine to run based on the scheduling algorithm. Among these available Goroutines, there may be Goroutines in other Go programs. If the Go runtime does not find an available Goroutine, the program may go to sleep.

Scheduling of Goroutines

Go runtime uses the Go scheduler scheduler to schedule the running of Goroutines. When we create a new Goroutine, it is added to the scheduler's run queue. When the scheduler is ready to run a Goroutine, it will select a Goroutine from the queue to run until the Goroutine blocks or calls a function such as time.Sleep. In this case, the scheduler pauses the execution of the Goroutine and puts it back in the queue until it is ready to run again.

Blocking of Goroutines

Blocking refers to the situation where Goroutines cannot continue to execute. When a Goroutine calls some blocking function, the Goroutine will be suspended until the function returns a result. These functions include: I/O operations, network requests, system calls, locks, etc. If a Goroutine is blocked, the scheduler puts the Goroutine back into the queue until it is ready to run again.

Synchronization of Goroutines

In Go, we can use channels (Channel) for synchronization and communication between Goroutines. A channel is a mechanism used to pass data between Goroutines, which can block the execution of Goroutines. The following is an example of using channels for synchronization:

package main

import (
    "fmt"
)

func main() {
    ch := make(chan int)

    go func() {
        fmt.Println("Goroutine starts")
        ch <- 1
    }()

    fmt.Println("Main goroutine waiting")
    <-ch
    fmt.Println("Main goroutine exiting")
}

In this example, we first create a channel ch, and then execute a function in a new Goroutine. In the function, we printed a message and wrote the number 1 to the channel. In the main function, we wait on the channel until we receive a value. Once we receive the value, the main function will exit. This is a very simple example, but it demonstrates how to use channels to synchronize between Goroutines.

Error handling of Goroutines

When an error occurs in Goroutine, it will crash and throw a Panic error. When an error occurs in a Goroutine, its error message will only be output to the console, and the Goroutine's status cannot be accessed. In order to avoid program crash, we can use the recover function to recover from Panic errors. The following is an example of using the recover function:

package main

import (
    "fmt"
)

func main() {
    // define a function to run inside Goroutine
    goroutineFunc := func() {
        defer func() {
            if err := recover(); err != nil {
                fmt.Println("Error:", err)
            }
        }()
        fmt.Println("Goroutine started")
        panic("Something went wrong")
    }

    // start Goroutine
    go goroutineFunc()

    // wait in case Goroutine is not finished yet
    var input string
    fmt.Scanln(&input)
    fmt.Println("End of program")
}

In this example, we first define a function goroutineFunc, which will be executed in a new Goroutine. In the function, we printed a message and called the panic function to simulate an error. In goroutineFunc, we use the defer keyword to define a function that is used to capture Panic errors. When we execute the panic function in goroutineFunc, it crashes and throws a Panic error. Since we used the recover function in the defer function, we can capture this error and output the error message on the console.

in conclusion

Goroutines are one of the core features of Go language concurrency. They can create and process parallel execution processes in the program and improve program performance. In this article, we learned how to use Goroutines in Go, including how to create Goroutines, Goroutines execution flow, scheduling, blocking, synchronization and error handling, etc. By using Goroutines, we can easily write efficient concurrent programs.

The above is the detailed content of How to use Goroutines in Go?. For more information, please follow other related articles on the PHP Chinese website!