Exploration pratique de la programmation concurrente en langage Go

Dans le domaine du développement logiciel actuel, la programmation simultanée est devenue une compétence indispensable. Surtout avec la popularité du cloud computing, du big data et des systèmes en temps réel, la demande de programmation simultanée augmente également. Parmi les nombreux outils et langages de programmation simultanée, le langage Go est célèbre pour son modèle de programmation simultanée concis et efficace. Cet article explorera les méthodes pratiques de programmation simultanée dans le langage Go et démontrera ses puissantes capacités de traitement simultané à travers des exemples de code spécifiques.

1. Bases de la programmation concurrente

En langage Go, la programmation concurrente est implémentée via goroutine. Goroutine est l'unité de base pour implémenter la concurrence dans le langage Go. Il s'agit en fait d'un thread léger. Grâce à goroutine, nous pouvons exécuter plusieurs tâches simultanément sans gérer explicitement la création et la destruction des threads.

Ce qui suit est un exemple simple de concurrence :

package main import ( "fmt" "time" ) func main() { go hello() time.Sleep(1 * time.Second) } func hello() { fmt.Println("Hello, goroutine!") }

Dans cet exemple, nous créons une goroutine via l'instructiongo hello(), afin que la fonctionhello()est exécuté dans un thread concurrent distinct. Le thread principal attend 1 seconde jusqu'àtime.Sleep(1 * time.Second)après le démarrage de la goroutine pour s'assurer que la goroutine a suffisamment de temps pour s'exécuter. Dans les applications réelles, nous utilisons généralementsync.WaitGroupou des canaux pour attendre la fin de goroutine.go hello()语句创建了一个goroutine，使得hello()函数在一个独立的并发线程中执行。主线程在启动goroutine后通过time.Sleep(1 * time.Second)等待1秒，以确保goroutine有足够的时间来执行。在实际应用中，我们通常会使用sync.WaitGroup或者通道来等待goroutine的完成。

二、通道(Channel)的使用

通道是Go语言中用于goroutine之间通信和数据同步的重要机制。通道可以看作是goroutine之间传递数据的管道，通过通道可以实现数据的安全传递和同步。

下面是一个使用通道进行数据传递的示例：

package main import ( "fmt" ) func main() { ch := make(chan int) go sendData(ch) go receiveData(ch) fmt.Scanln() } func sendData(ch chan int) { ch <- 1 ch <- 2 ch <- 3 close(ch) } func receiveData(ch chan int) { for { data, ok := <-ch if !ok { break } fmt.Println(data) } }

在这个示例中，我们创建了一个整型通道ch，然后通过go sendData(ch)和go receiveData(ch)启动两个goroutine。sendData()函数向通道发送数据，receiveData()函数从通道接收数据并打印。这样，我们实现了在两个goroutine之间安全传递数据的功能。

三、并发控制与同步

在实际的并发编程场景中，通常需要对并发执行的goroutine进行控制和同步，以避免竞态条件和数据竞争问题。Go语言提供了多种机制来实现并发控制和同步，如sync.Mutex、sync.WaitGroup等。

下面是一个使用sync.WaitGroup实现并发控制的示例：

package main import ( "fmt" "sync" ) func main() { var wg sync.WaitGroup for i := 1; i <= 3; i++ { wg.Add(1) go func(i int, wg *sync.WaitGroup) { defer wg.Done() fmt.Println("Task", i) }(i, &wg) } wg.Wait() fmt.Println("All tasks are done.") }

在这个示例中，我们创建了一个sync.WaitGroup实例wg，然后在循环中为每个goroutine调用wg.Add(1)增加计数器，表示有一个goroutine即将执行。在每个goroutine执行完成后，通过defer wg.Done()减少计数器。最后，调用wg.Wait()