GoLang Tutorial - Channels ("<-")

Continued from Goroutines, in this post, we'll learn how Goroutines communicate using channels.

chan T is a channel of type T:

These types are the types of data that the channels are allowed to transport. No other types are allowed to be transported using the channels.

Channels are a typed pipe through which we can send and receive values with the channel operator, "<-". So, the syntax to send and receive data from a channel are:

data := <- my_channel // read from channel my_channel  
my_channel <- data    // write to channel my_channel  

We used the time.Sleep() in Goroutines to make the main Goroutine wait for the hello Goroutine to finish:

Let's modify the code using channels:

The line of code marked in red-box (<-finished) is blocking. In other words, the control will not move to the next line of code until the Goroutine writes data to the finished channel. As we can guess, this eliminates the need for the time.Sleep() we used before to prevent the main Goroutine from exiting.

Note that the line <-finished receives data from the finished channel but does not use or store that data in any variable. This is perfectly legal.

Here is a modified version of sample code from Channels which sums the numbers in a slice, distributing the work between two Goroutines. Once both Goroutines have completed their computation, it calculates the final result.

By default, sends and receives block until the other side is ready. This allows Goroutines to synchronize without explicit locks or condition variables. In the code, we got the value x first, and it waits until y value arrives before printing out the sum x+y.

The following code shows several ways of calculating Fibonacci sequence, recursive and iterative (via closure or via channel):

The code: fibonacci-channel.go

Go Tutorial

1. GoLang Tutorial - HelloWorld
2. Calling code in an external package & go.mod / go.sum files
3. Workspaces
4. Workspaces II
5. Visual Studio Code
6. Data Types and Variables
7. byte and rune
8. Packages
9. Functions
10. Arrays and Slices
11. A function taking and returning a slice
12. Conditionals
13. Loops
14. Maps
15. Range
16. Pointers
17. Closures and Anonymous Functions
18. Structs and receiver methods
19. Value or Pointer Receivers
20. Interfaces
21. Web Application Part 0 (Introduction)
22. Web Application Part 1 (Basic)
23. Web Application Part 2 (Using net/http)
24. Web Application Part 3 (Adding "edit" capability)
25. Web Application Part 4 (Handling non-existent pages and saving pages)
26. Web Application Part 5 (Error handling and template caching)
27. Web Application Part 6 (Validating the title with a regular expression)
28. Web Application Part 7 (Function Literals and Closures)
29. Building Docker image and deploying Go application to a Kubernetes cluster (minikube)
30. Serverless Framework (Serverless Application Model-SAM)
31. Serverless Web API with AWS Lambda
32. Arrays vs Slices with an array left rotation sample
33. Variadic Functions
34. Goroutines
35. Channels ("<-")
36. Channels ("<-") with Select
37. Channels ("<-") with worker pools
38. Defer
39. GoLang Panic and Recover
40. String Formatting
41. JSON
42. SQLite
43. Modules 0: Using External Go Modules from GitHub
44. Modules 1 (Creating a new module)
45. Modules 2 (Adding Dependencies)
46. AWS SDK for Go (S3 listing)
47. Linked List
48. Binary Search Tree (BST) Part 1 (Tree/Node structs with insert and print functions)
49. Go Application Authentication I (BasicAuth, Bearer-Token-Based Authentication)
50. Go Application Authentication II (JWT Authentication)