Home >Backend Development >Golang >How to use Go language for code scheduling and task management practice
How to use Go language for code scheduling and task management practice
As a simple and efficient programming language, Go language has unique advantages in concurrent programming. Through reasonable scheduling and task management, we can give full play to the concurrency characteristics of the Go language and improve program performance and efficiency. This article will introduce the practice of using Go language for code scheduling and task management, and provide code examples.
go
to create a new Goroutine, which is a lightweight thread. Goroutine can execute tasks concurrently without the need to manually manage the creation and destruction of threads. The following is a sample code of Goroutine: package main import ( "fmt" "time" ) func main() { go sayHello() // 创建一个新的Goroutine time.Sleep(time.Second) // 主线程等待1秒钟 } func sayHello() { fmt.Println("Hello, Go!") }
In this example, we use the go
keyword to create a new Goroutine to execute the sayHello
function , the main thread waits for 1 second through the time.Sleep
function to ensure that Goroutine has enough time to execute. Run the program and you will see the "Hello, Go!" output.
package main import "fmt" func main() { ch := make(chan int) // 创建一个通道 go produce(ch) // 创建生产者Goroutine go consume(ch) // 创建消费者Goroutine // 主线程等待Goroutine完成 var input string fmt.Scanln(&input) } func produce(ch chan<- int) { for i := 0; i < 5; i++ { ch <- i // 发送数据到通道 } close(ch) // 关闭通道 } func consume(ch <-chan int) { for i := range ch { fmt.Println("Consumed:", i) // 从通道接收数据 } }
In this example, we create a channel ch
, and then create the producer and producer respectively. Goroutine for consumers. The producer Goroutine sends data to the channel through ch <- i
, and the consumer Goroutine receives data from the channel through i := <- ch
. When the producer completes sending data, we close the channel through close(ch)
to notify the consumer Goroutine to stop receiving.
package main import ( "fmt" "sync" "time" ) var count int // 共享资源 var mutex sync.Mutex // 互斥锁 func main() { for i := 0; i < 10; i++ { go increment() // 创建多个Goroutine递增count } time.Sleep(time.Second) // 主线程等待1秒钟 fmt.Println("Final count:", count) } func increment() { mutex.Lock() // 加锁 defer mutex.Unlock() // 解锁 count++ // 访问共享资源 }
In this example, we use sync.Mutex
to create a mutex lockmutex
. In the increment
function, we lock it through mutex.Lock()
, so that only one Goroutine can access the shared resource, and other Goroutines will wait. At the end of the increment
function, we unlock it via mutex.Unlock()
so that other Goroutines can continue to access the shared resource.
By rationally using Goroutine's scheduling and task management, channels for data communication, and mutex locks for concurrency control, we can give full play to the concurrency features of the Go language and improve program performance and efficiency. I hope the practical examples in this article can help you better understand and apply concurrent programming in Go language.
The above is the detailed content of How to use Go language for code scheduling and task management practice. For more information, please follow other related articles on the PHP Chinese website!