Creating Goroutines

In this lesson, explore creating goroutines through one small Go program, and connect its output to the language rules behind it.

Goroutines can use named functions or function literals. Pass changing loop values as arguments to make their intended values explicit.

When many results arrive in arbitrary order, store them by index so output stays meaningful. This matters more than assuming one goroutine will run first.

Follow this diagram before executing the example. Check where a value or decision changes what runs next.

This example is a complete program. Save it as main.go or paste it into the Go Playground.

Go code

package main

import "fmt"

type Result struct{ Index, Square int }

func main() {
	ch := make(chan Result, 3)
	for i := 1; i <= 3; i++ {
		go func(n int) { ch <- Result{n - 1, n * n} }(i)
	}
	squares := make([]int, 3)
	for range squares {
		r := <-ch
		squares[r.Index] = r.Square
	}
	fmt.Println(squares)
}

Output

[1 4 9]

Each worker captures its input through an argument, then returns its index and square. The main goroutine reconstructs [1 4 9] regardless of completion order.

• Do not rely on goroutine completion order.
• For long-running tasks, create a bounded amount of work rather than unlimited goroutines.

Launch workers for numbers 1 through 5 and collect five ordered square values.

Tip: Edit the example above, predict the output, and run the modified code to test your reasoning.

You have practiced Creating Goroutines in a small, self-contained program. The important habit is to predict what runs, inspect the actual output and distinguish the language rule from the particular example.

Before continuing, make sure you can explain the program to someone who has not seen it, including the line that changes its result.