Discuss the usage of Sleep function in Golang

Go language (Golang) is an open source programming language developed by Google. Go has natural support for concurrent programming and provides some built-in functions and tools to facilitate developers to perform concurrent programming. Among them, the Sleep function is provided in the time package. This article will explore the usage of the Sleep function in Golang.

1. Sleep function overview

The Sleep function is used to put the current coroutine (goroutine) into sleep state and suspend execution for a period of time. The function prototype is as follows:

func Sleep(d Duration)

Among them, Duration is a type representing a time period. The minimum time unit supported is nanoseconds (ns), and the maximum time is approximately 290 years. In the program, you can use the constants provided in the time package to represent different time periods, such as:

const (
    Nanosecond  Duration = 1
    Microsecond          = 1000 * Nanosecond
    Millisecond          = 1000 * Microsecond
    Second               = 1000 * Millisecond
    Minute               = 60 * Second
    Hour                 = 60 * Minute
)

2. Sleep function usage examples

Below we demonstrate the Sleep function through several examples usage.

1. Basic usage

package main

import (
    "fmt"
    "time"
)

func main() {
    fmt.Println("start")
    time.Sleep(1 * time.Second)
    fmt.Println("end")
}

After executing the program, the output is as follows:

start
(end 1秒后输出)
end

After the program starts, "end" is output after sleeping for 1 second.

2. Precise time control

When multiple goroutines are executed concurrently, in order to ensure the correctness of the program, it is necessary to ensure the execution of each goroutine The time is as precise as possible. The following example demonstrates how to use the Sleep function to precisely control time.

package main

import (
    "fmt"
    "time"
)

func main() {
    for i := 0; i <p>After executing the program, the output is as follows: </p><pre class="brush:php;toolbar:false">start
start
start
(end 1秒后输出)
end
end
end

In the above code, we used a for loop to create 3 coroutines for concurrent execution, and the execution time of each coroutine is 1 second. bell. The sleep time is 2 seconds, ensuring that each coroutine can be executed and output as expected.

3. Prevent repeated operations in a short time

In the actual programming process, sometimes it is necessary to prevent repeated operations in a short time. For example, after clicking a button, you need to wait for a while before clicking again. The following example demonstrates how to use the Sleep function to implement this functionality.

package main

import (
    "fmt"
    "time"
)

func main() {
    click()
    time.Sleep(2 * time.Second)
    click()
}

func click() {
    now := time.Now()
    fmt.Println(now.Format("2006-01-02 15:04:05"))
    time.Sleep(1 * time.Second)
}

After executing the program, the output is as follows:

(start time)
2022-06-15 20:35:43
(end time)
2022-06-15 20:35:44
(start time)
2022-06-15 20:35:46
(end time)
2022-06-15 20:35:47

In the above code, we define a click function, which is used to record the current time and sleep for 1 second. In the main function, we first call the click function once, and then wait 2 seconds to call it again. Since we waited 2 seconds before the second call, the second call will be executed 1 second after the first call.

3. Conclusion

This article introduces the usage and examples of Sleep function in Golang.

Using the Sleep function can effectively control the execution time of concurrent programs and ensure the correctness and stability of the program.

Special attention should be paid to the fact that when using the Sleep function, try to avoid using a long sleep time. Too long sleep time will block coroutine execution and affect program performance.

The above is the detailed content of Discuss the usage of Sleep function in Golang. For more information, please follow other related articles on the PHP Chinese website!