DEV Community

Ashfiquzzaman Sajal
Ashfiquzzaman Sajal

Posted on

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)

<span class="n">start</span> <span class="o">:=</span> <span class="n">time</span><span class="o">.</span><span class="n">Now</span><span class="p">()</span>
<span class="k">go</span> <span class="n">says</span><span class="p">(</span><span class="o">&amp;</span><span class="n">wg</span><span class="p">,</span> <span class="s">"Hello"</span><span class="p">)</span>
<span class="n">wg</span><span class="o">.</span><span class="n">Wait</span><span class="p">()</span>

<span class="n">duration</span> <span class="o">:=</span> <span class="n">time</span><span class="o">.</span><span class="n">Since</span><span class="p">(</span><span class="n">start</span><span class="p">)</span>
<span class="n">fmt</span><span class="o">.</span><span class="n">Println</span><span class="p">(</span><span class="s">"Duration:"</span><span class="p">,</span> <span class="n">duration</span><span class="p">)</span>
Enter fullscreen mode Exit fullscreen mode

}

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)

<span class="n">start</span> <span class="o">:=</span> <span class="n">time</span><span class="o">.</span><span class="n">Now</span><span class="p">()</span>
<span class="k">for</span> <span class="n">i</span> <span class="o">:=</span> <span class="m">0</span><span class="p">;</span> <span class="n">i</span> <span class="o">&lt;</span> <span class="m">50</span><span class="p">;</span> <span class="n">i</span><span class="o">++</span> <span class="p">{</span>
    <span class="n">says</span><span class="p">(</span><span class="o">&amp;</span><span class="n">wg</span><span class="p">,</span> <span class="s">"Hello"</span><span class="p">)</span>
<span class="p">}</span>
<span class="n">wg</span><span class="o">.</span><span class="n">Wait</span><span class="p">()</span>

<span class="n">duration</span> <span class="o">:=</span> <span class="n">time</span><span class="o">.</span><span class="n">Since</span><span class="p">(</span><span class="n">start</span><span class="p">)</span>
<span class="n">fmt</span><span class="o">.</span><span class="n">Println</span><span class="p">(</span><span class="s">"Duration:"</span><span class="p">,</span> <span class="n">duration</span><span class="p">)</span>
Enter fullscreen mode Exit fullscreen mode

}

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)

<span class="n">start</span> <span class="o">:=</span> <span class="n">time</span><span class="o">.</span><span class="n">Now</span><span class="p">()</span>
<span class="k">for</span> <span class="n">i</span> <span class="o">:=</span> <span class="m">0</span><span class="p">;</span> <span class="n">i</span> <span class="o">&lt;</span> <span class="m">50</span><span class="p">;</span> <span class="n">i</span><span class="o">++</span> <span class="p">{</span>
    <span class="k">go</span> <span class="n">says</span><span class="p">(</span><span class="o">&amp;</span><span class="n">wg</span><span class="p">,</span> <span class="s">"Hello"</span><span class="p">)</span>
<span class="p">}</span>
<span class="n">wg</span><span class="o">.</span><span class="n">Wait</span><span class="p">()</span>

<span class="n">duration</span> <span class="o">:=</span> <span class="n">time</span><span class="o">.</span><span class="n">Since</span><span class="p">(</span><span class="n">start</span><span class="p">)</span>
<span class="n">fmt</span><span class="o">.</span><span class="n">Println</span><span class="p">(</span><span class="s">"Duration:"</span><span class="p">,</span> <span class="n">duration</span><span class="p">)</span>
Enter fullscreen mode Exit fullscreen mode

}

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! 😎

Top comments (0)