What is the reason why go language supports high concurrency?

Reason: Go language implements multi-coroutine development from the keyword level during design. The go language implements the CSP concurrency model as the basis for concurrency. The bottom layer uses goroutine as the concurrent entity. Goroutine is very lightweight and can create hundreds of thousands of entities. The entities continue anonymous messaging through channels to decouple them, and are implemented at the language level. Automatic scheduling is implemented, which shields many internal details and provides simple syntax keywords to the outside world, which greatly simplifies the thinking transformation of concurrent programming and the complexity of managing threads.

The operating environment of this tutorial: Windows 7 system, GO version 1.18, Dell G3 computer.

The legend of go

There are many legends about Go in the market. "It naturally supports high concurrency, and its execution speed is close to C. Network services Close to Nginx…”. Everything else is okay, but the only thing that is difficult to understand is "naturally supports high concurrency", especially the word "naturally", which really makes people feel full of high-end and mysterious.

Let’s first take a look at how simple it is to implement concurrent operations in go. Let’s look at the code:

func main()  {
   go add(3,6)  
   go add(1,6)  
   time.Sleep(time.Second)}func add(a int,b int)  {
   result := a+b
   fmt.Println(result)}

The go keyword implements the coroutine opening call. If no waiting is performed, the main thread End, the coroutine will end immediately.

Concurrency of go

In fact, the goroutine in the go language is the reference (Communicating Sequential Process) model, and the channel in the original CSP Tasks are executed immediately, and the Go language adds a cache, that is, tasks can be temporarily stored and then executed one by one in sequence when the execution process is ready.

But in fact, the Go language does not fully implement all the theories of the CSP model, but only borrows the two concepts of process and channel. The performance of process in the Go language is that goroutine is an entity that is actually executed concurrently. Data sharing is achieved between each entity through channel communication.

1) goroutine

Goroutine is the actual concurrent execution entity of go. Its bottom layer is to use coroutine (coroutine) to achieve concurrency. Coroutine is a kind of running in user mode. For user threads, the starting point for Go bottom layer to use coroutine is because it has the following characteristics:

1. User space avoids the cost caused by switching between kernel mode and user mode
2. Can be used by Scheduling at the language and framework layers
3. Smaller stack space allows the creation of a large number of instances

2) Channel

Used in go channel in CSP. The channel is created separately and can be passed between processes. Its communication mode is similar to the boss-worker mode. An entity sends a message to the channel and then listens to the entity processing of the channel. The relationship between the two entities is Anonymous, this achieves decoupling between entities. The channel is synchronous and a message is sent to the channel. It must eventually be consumed by another entity. In principle, it is actually a blocking message queue.

3) Scheduler

goroutine provides a scheduler at the golang level. The steal working algorithm is added to the scheduler. Goroutine can be preempted asynchronously, so there is no Loops in function calls no longer deadlock the scheduler or significantly slow down garbage collection. In addition, go encapsulates the network IO library, shields complex details, provides unified syntax keyword support to the outside world, and simplifies the cost of writing concurrent programs.

Summary

Golang implements the CSP concurrency model as the basis for concurrency. The bottom layer uses goroutine as the concurrent entity. Goroutine is very lightweight. Create hundreds of thousands of entities. Continuous anonymous messaging between entities through channels decouples them, and realizes automatic scheduling at the language level. This shields many internal details and provides simple syntax keywords to the outside world, which greatly simplifies the thinking transformation of concurrent programming and the complexity of managing threads. .

Summary in one sentence: Go language implements multi-coroutine development from the keyword level during design, as if the language inherently supports high concurrency.

【Related recommendations: Go video tutorial, Programming teaching】

The above is the detailed content of What is the reason why go language supports high concurrency?. For more information, please follow other related articles on the PHP Chinese website!