Скачать или смотреть Understanding time.After in Go: Why Your Timeout Might Not Work as Expected

Learn why the `time.After` function in Go might not behave as you expect and how to implement a proper timeout in your Go routines.
---
This video is based on the question https://stackoverflow.com/q/76404356/ asked by the user 'Dudadi' ( https://stackoverflow.com/u/12991724/ ) and on the answer https://stackoverflow.com/a/76404476/ provided by the user 'Tùng Đào Thanh Tùng' ( https://stackoverflow.com/u/4097963/ ) at 'Stack Overflow' website. Thanks to these great users and Stackexchange community for their contributions.

Visit these links for original content and any more details, such as alternate solutions, latest updates/developments on topic, comments, revision history etc. For example, the original title of the Question was: it is quite common way to implement a timeout, why time.After is not working

Also, Content (except music) licensed under CC BY-SA https://meta.stackexchange.com/help/l...
The original Question post is licensed under the 'CC BY-SA 4.0' ( https://creativecommons.org/licenses/... ) license, and the original Answer post is licensed under the 'CC BY-SA 4.0' ( https://creativecommons.org/licenses/... ) license.

If anything seems off to you, please feel free to write me at vlogize [AT] gmail [DOT] com.
---
Understanding time.After in Go: Why Your Timeout Might Not Work as Expected

When working with Go's concurrency features, you may encounter unexpected behaviors, particularly when it comes to handling timeouts. A common issue developers face is when they expect a timeout using time.After to trigger after a specific duration, but it doesn't seem to work correctly. In this guide, we'll break down a specific scenario that demonstrates this problem and explain how to resolve it.

The Problem: Unresponsive Timeout

In the provided Go code snippet, a goroutine is created to send "result" to a channel every second. Meanwhile, the main function attempts to listen for results or a timeout, which is set to occur after three seconds. However, instead of the expected "timeout" message appearing after 3 seconds, it only displays after all "result" messages (10 in total) have been printed out after 10 seconds. This leads to confusion about why time.After isn’t functioning as anticipated.

The Code in Question

Here is the original code for reference:

[[See Video to Reveal this Text or Code Snippet]]

What Goes Wrong?

The problem arises from the way time.After is implemented in the select statement:

New Timer on Every Iteration: Each time the for loop iterates, a new channel from time.After is created. This means that after 3 seconds have passed since the last loop began, there will be a valid timeout channel, but it will not cause the first instance of time.After to terminate any ongoing operations. Essentially, every iteration checks against a fresh timer that doesn't accumulate waiting time correctly.

The Solution: Reformulating the Timeout

To achieve the desired timeout functionality, you need to create the timeout channel outside of the loop. This ensures that the same timer is used for the entire duration of the loop's execution. Here’s how to modify the code:

Revised Code

[[See Video to Reveal this Text or Code Snippet]]

Key Changes Explained

Single Timer Usage: By creating timeoutChan before entering the loop, it maintains its state as the loop executes. This way, the timeout will effectively occur precisely after 3 seconds, regardless of how many "result" messages have been processed thus far.

Conclusion: Understanding Concurrency in Go

In Go, working with goroutines and channels can sometimes introduce confusion, particularly regarding timing and synchronization. The issue with time.After in the initial approach highlights the importance of understanding how concurrency works in Go. By ensuring that your timeout channels are established outside of iterative structures, you can prevent unexpected behaviors and maintain control over your timeout logic.

Following these guidelines not only helps you avoid pitfalls but also strengthens your grasp of Go's concurrency features. Happy coding!