Golang Concurrency: A Fun and Fast Ride

Alright, folks, buckle up! We’re going to see how concurrency in Go can make your programs way faster. We’ll start with some basic stuff and then level up with some concurrency magic. Let’s roll!

Step 1: Single Non-Concurrent Program

First up, we have a plain and simple program that prints “Hello” 50 times. This one runs in a single thread, so it’s pretty slow and boring.

Code Snippet (Single Non-Concurrent)

package main import ( "fmt" "time"
) func says(s string) { for i := 0; i < 50; i++ { time.Sleep(100 * time.Millisecond) fmt.Println(s) }
} func main() { start := time.Now() says("Hello") duration := time.Since(start) fmt.Println("Duration:", duration)
}
Enter fullscreen mode Exit fullscreen mode

Result

  • Duration: Approximately 5.5 seconds.

Step 2: 50 Non-Concurrent Programs

Now, imagine running that boring program 50 times in a row. Yeah, it’s going to take forever!

Code Snippet (50 Non-Concurrent)

package main import ( "fmt" "time"
) func says(s string) { for i := 0; i < 50; i++ { time.Sleep(100 * time.Millisecond) fmt.Println(s) }
} func main() { start := time.Now() for i := 0; i < 50; i++ { says("Hello") } duration := time.Since(start) fmt.Println("Duration:", duration)
}
Enter fullscreen mode Exit fullscreen mode

Result

  • Duration: Approximately 5.5 seconds * 50 = 275 seconds. Ouch!

Step 3: Single Concurrent Program

Alright, now let’s add some flair! We’ll run a single instance of our program using concurrency. Check it out!

Code Snippet (Single Concurrent)

package main import ( "fmt" "sync" "time"
) func says(wg *sync.WaitGroup, s string) { defer wg.Done() for i := 0; i < 50; i++ { time.Sleep(100 * time.Millisecond) fmt.Println(s) }
} func main() { var wg sync.WaitGroup wg.Add(1) start := time.Now() go says(&wg, "Hello") wg.Wait() duration := time.Since(start) fmt.Println("Duration:", duration)
}
Enter fullscreen mode Exit fullscreen mode

Result

  • Duration: Approximately 5.5 seconds.

Step 4: 50 Concurrent Programs Without go Keyword

Imagine a pencil drawing of a confident child sitting at a table. The child’s face is a mix of determination and mischief. Their eyes sparkle with curiosity, and their lips are curved into a mischievous grin. It’s as if they’re plotting some clever adventure while perched on that table.
Alright, so what happens if we run 50 concurrent-like programs without actually using concurrency? Let’s find out! I’m feeling super confident this will show some improvement, although not as much as using go. This should be awesome! Fingers crossed! 🤞

Code Snippet (50 “Concurrent” Without go)

package main import ( "fmt" "sync" "time"
) func says(wg *sync.WaitGroup, s string) { defer wg.Done() for i := 0; i < 50; i++ { time.Sleep(100 * time.Millisecond) fmt.Println(s) }
} func main() { var wg sync.WaitGroup wg.Add(50) start := time.Now() for i := 0; i < 50; i++ { says(&wg, "Hello") } wg.Wait() duration := time.Since(start) fmt.Println("Duration:", duration)
}
Enter fullscreen mode Exit fullscreen mode

Result

  • Duration: Approximately 5.5 seconds * 50 = 275 seconds. Still slow!

Imagine a pencil drawing of a child with an adorable face, but there’s a twist: the child is clearly angry. His tiny eyebrows are furrowed, and his pouty lips add to the overall cuteness. It’s a delightful blend of innocence and frustration that makes you chuckle. 🎨😄
Alright, picture this: I was like, “Yeah, this is going to be awesome! We’ll see some speed-up for sure!” But then… reality hit me like a ton of bricks. 275 seconds?! What on earth just happened? 😱

It’s like expecting to ride a super-fast roller coaster but ending up on a snail ride instead. I mean, I was so confident, thinking, “This is it, we’re going to see some serious improvement!” But no, it was embarrassingly slow, and I felt like I just discovered gravity for the first time. Seriously, what was I thinking?

So, there I was, facepalming and feeling a mix of shame and anger. But hey, lesson learned! Sometimes, you’ve got to fail spectacularly to understand why concurrency is such a game-changer. Alright, let’s get to the real deal!

Step 5: 50 Concurrent Programs with go Keyword

Now for the grand finale! Let’s run 50 programs concurrently using the go keyword. This is where the magic happens! 🌟

Code Snippet (50 Concurrent with go)

package main import ( "fmt" "sync" "time"
) func says(wg *sync.WaitGroup, s string) { defer wg.Done() for i := 0; i < 50; i++ { time.Sleep(100 * time.Millisecond) fmt.Println(s) }
} func main() { var wg sync.WaitGroup wg.Add(50) start := time.Now() for i := 0; i < 50; i++ { go says(&wg, "Hello") } wg.Wait() duration := time.Since(start) fmt.Println("Duration:", duration)
}
Enter fullscreen mode Exit fullscreen mode

Result

  • Duration: Approximately 5.5 seconds. Boom! 🎉

Conclusion

See the difference? When we ran 50 non-concurrent programs, it took forever. But with concurrency, we did it in the same time as a single run. Concurrency in Go is like having 50 clones of yourself doing the work at the same time. It’s faster, cooler, and a lot more fun!

So, get out there and start using concurrency in your Go programs. It’s a game-changer! Happy coding, and stay awesome! 😎


Discover more from Coursity

Subscribe to get the latest posts sent to your email.

Leave a Comment

Your email address will not be published. Required fields are marked *

Discover more from Coursity

Subscribe now to keep reading and get access to the full archive.

Continue reading

Scroll to Top