Introduction to concurrency in go language (with code)

When asked why we use Go language, we must mention the concurrent programming of Go language. Writing very cumbersome and complex concurrent programs in C language always seems so convenient in Go language.

Concurrent programs in Go rely on two things: goroutine and channel

Understand what goroutine is?

For beginners Scholars, goroutine can be directly understood as a thread. When you call go on a function and start a goroutine, it is equivalent to starting a thread to execute the function.

In fact, a goroutine is not equivalent to a thread. The emergence of goroutine is to replace the original thread concept and become the smallest scheduling unit.

Once a goroutine is run, it first searches for the leading thread. If the thread is blocked, it will be assigned to an idle thread. If there is no idle thread, a new thread will be created. Note that when the goroutine completes execution, the thread will not be recycled and pushed out, but will become an idle thread.

The use of goroutine

is very simple to use, add a go

f(11)

before the function

go f(11) //This is to let the f() function run as a goroutine

But go has a shortcoming. What should I do if the main thread has to wait for a goroutine to finish before processing? Take an example from "Learning Go Language".

Why should line 18 sleep? This is to wait for the above two go ready processes to be completed.

Okay, here comes a requirement: after a goroutine ends, data must be transmitted to the main thread to tell the main thread that the goroutine has ended.

The concept of channel is introduced here

Use of channel

The meaning of channel can be understood in vernacular like this: Main The thread tells everyone that you can open a goroutine, but I opened a pipe in my main thread. After you finish what you want to do, stuff something into the pipe to tell me that you have completed it.

The above example can be changed to:

Some information obtained from this program:

1 channel only You can use make to create

The basic format is c := make(chan int)

int indicates what type of data this pipe can transmit

2 The operation of inserting data into the channel

c

Is it very vivid?

3 Outputting data from the channel

4 Why does it need to be output twice (lines 4 and 5?)

Because 2 and 3 start two Each goroutine outputs a 1 to the pipe, so the main thread has to receive it twice to indicate that both goroutines have ended.

Further understanding of channel:

Channel is divided into two types: one with buffer and one without buffer. The default is no buffer.

ci := make(chan int) //No buffer

cj := make(chan int, 0) //No buffer

cs := make(chan int, 100) //With buffer

Buffered channel , so you should pay attention to "put" before "get"

Unbuffered channel, so pay attention to "get" before "put"

Also output hello world first, use buffered channel The channel and unbuffered channel are as follows:

Buffered channel:

var a string
var c = make(chan int, 10)
  
func f() {
    a = "hello, world"
    c <- 0
}
  
func main() {
    go f()
    <-c
    print(a)
 
}

There is a buffer here, so the operation of putting data is c<- 0 precedes the data fetch operation <-c

Unbuffered channel:

var a string
var c = make(chan int)
  
func f() {
    a = "hello, world"
    <-c
}
  
func main() {
    go f()
    c <- 0
    print(a)
 
}

Since c is an unbuffered channel, the fetch operation must be guaranteed

Recommendation: golang tutorial column

The above is the detailed content of Introduction to concurrency in go language (with code). For more information, please follow other related articles on the PHP Chinese website!