Why concurrency is needed in Go - Performance Analysis

Time Complexity: Why concurrency is needed

O(n)

Understanding Time Complexity

Concurrency helps programs do many things at once, making them faster and more efficient.

We want to see how adding concurrency changes how long a program takes to run as it handles more work.

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

package main

import (
	"fmt"
	"time"
)

func work(id int) {
	time.Sleep(1 * time.Second) // simulate work
	fmt.Println("Work done", id)
}

func main() {
	for i := 1; i <= 5; i++ {
		work(i)
	}
}

This code runs five tasks one after another, each taking about one second.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: Running the work function five times in a loop.
• How many times: Exactly 5 times, one after another.

How Execution Grows With Input

Explain the growth pattern intuitively.

Input Size (n)	Approx. Operations (seconds)
10	10 seconds
100	100 seconds
1000	1000 seconds

Pattern observation: The total time grows directly with the number of tasks because they run one after another.

Final Time Complexity

Time Complexity: O(n)

This means the total time increases in a straight line as you add more tasks, because each task waits for the previous one to finish.

Common Mistake

[X] Wrong: "Running tasks one after another is just as fast as running them at the same time."

[OK] Correct: When tasks run one by one, total time adds up. Running tasks at the same time can save time by doing many things together.

Interview Connect

Understanding how concurrency changes time helps you explain why programs can be faster and more efficient, a key skill in real-world coding.

Self-Check

"What if we changed the code to run all tasks concurrently using goroutines? How would the time complexity change?"