Why use Goroutines instead of Threads

Why use Goroutines instead of Threads

introduce

Both Goroutines and Threads are built for concurrency. Goroutines don’t exactly replace Threads. Because goroutines are actually built on top of a set of Threads. The ability to multipath concurrent execution is multiplexed on the Threads group. When a Goroutine needs to run, it is automatically mounted to a thread. And this series of scheduling is black box to the developer, no perception.

Advantages of Goroutines over Threads

• Overhead is very cheap, requiring only a few kilobytes per Goroutine stack, and can grow and shrink as the application needs.
• A thread can have multiple goroutines, and perhaps thousands of goroutines can be processed by a single thread. If there are goroutines in the thread that need to be suspended, waiting for user input, the other goroutines that need to be run are moved to a new thread. All of these are abstracted and can be used by developers with simple apis.

Using goroutine

package main

import (
	"fmt"
	"time"
)

func hello() {
	fmt.Println("hello goroutine\r")
}
func main() {
	go hello()
	time.Sleep(1 * time.Second)
	fmt.Println("main function\r")}Copy the code

Sleep(1 * time.second). Because:

• When a goroutine is created, it immediately returns, executes the statement, and fools all the return values of the Goroutine.
• If the main goroutine exits, no other Goroutine will be executed;
• If you comment out the sentence Sleep, run it again and you won’t see the Hello Goroutine output.

More than one goroutine

package main

import (
	"fmt"
	"time"
)

func numbers() {
	for i := 1; i <= 5; i++ {
		time.Sleep(500 * time.Millisecond)
		fmt.Printf("%d ", i)
	}
}
func alphabets() {
	for i := 'a'; i <= 'c'; i++ {
		time.Sleep(1000 * time.Millisecond)
		fmt.Printf("%c ", i)
	}
}
func main() {
	go numbers()
	go alphabets()
	time.Sleep(3000 * time.Millisecond)
	fmt.Println("main terminated")}Copy the code

The output is:

a 1 b 2 c 3 d 4 e 5 main terminated
Copy the code

The table below describes the timing of the execution of multiple Goroutines. You can see that multiple Goroutines are executed simultaneously.

• numbers goroutine

• alphabets goroutine

• main goroutine

reference

Part 21: Goroutines

For more content, follow me on Github.