Partage de pratiques de programmation simultanée Golang : comment utiliser Goroutines pour créer des serveurs hautes performances

Partage de pratiques de programmation simultanée Golang : Comment utiliser Goroutines pour créer des serveurs hautes performances

Introduction :
Avec le développement rapide d'Internet, les développeurs sont souvent confrontés au problème de la création de serveurs hautes performances. Dans Golang, cela peut être très bien réalisé en utilisant Goroutines pour la programmation simultanée. Cet article partagera quelques expériences pratiques pour vous aider à comprendre comment utiliser Goroutines pour créer des serveurs hautes performances et fournira des exemples de code pour référence.

1. Que sont les Goroutines ?
Les Goroutines sont l'unité de base de la programmation simultanée dans Golang. Il peut être considéré comme un thread léger s’exécutant simultanément avec d’autres Goroutines. Comparés aux threads du système d'exploitation, les Goroutines sont plus légers, moins chers à démarrer et à détruire et peuvent utiliser très efficacement les processeurs multicœurs du matériel moderne.

2. Scénarios d'utilisation de Goroutines
Lors de la création de serveurs hautes performances, l'utilisation de Goroutines peut apporter de nombreux avantages. Voici quelques scénarios d'utilisation courants :

1. Traitement parallèle des requêtes : utilisez Goroutines pour traiter plusieurs requêtes en même temps et améliorer le débit du serveur.
2. Opérations d'E/S asynchrones : les Goroutines peuvent continuer à effectuer d'autres tâches en attendant la fin des opérations d'E/S, exploitant ainsi pleinement les ressources du processeur.
3. Traitement simultané des données : l'utilisation de Goroutines pour le traitement simultané des données peut accélérer le traitement des données.

3. Expérience pratique de l'utilisation de Goroutines pour créer des serveurs hautes performances

1. Contrôler raisonnablement le nombre de Goroutines : lorsque nous utilisons des Goroutines pour traiter des requêtes, nous devons tenir compte des limitations de ressources du système. Il est important de définir le nombre de Goroutines de manière appropriée pour éviter une dégradation des performances due à l'épuisement des ressources. Vous pouvez utiliser la fonction runtime.NumCPU() de Golang pour obtenir le nombre de cœurs de processeur dans le système actuel et l'ajuster en fonction de la situation réelle. runtime.NumCPU()函数获取当前系统的CPU核心数量，并根据实际情况进行调整。
   下面是一个示例代码片段，演示如何控制Goroutines数量：

func main() {
    // 获取系统CPU核心数量
    numCPU := runtime.NumCPU()

    // 根据CPU核心数量设置GOMAXPROCS
    runtime.GOMAXPROCS(numCPU)

    // 启动Goroutines
    for i := 0; i < numCPU; i++ {
        go processRequest()
    }

    // 主Goroutine等待所有子Goroutines执行完成
    wg.Wait()
}

func processRequest() {
    // 处理请求的逻辑
    // ...
    wg.Done()
}

2. 使用通道（channel）进行Goroutines间的通信：通道是Goroutines之间进行数据传递的主要机制。一种常见的模式是使用一个接收通道和一个发送通道进行交互。接收通道用于接收任务，而发送通道用于返回处理结果。
   以下是一个简单的示例代码，演示如何使用通道进行Goroutines间的通信：

func main() {
    tasks := make(chan Task, 10)    // 接收通道
    results := make(chan Result, 10)    // 发送通道

    // 启动Goroutines
    for i := 0; i < 4; i++ {
        go worker(tasks, results)
    }

    // 发送任务到接收通道
    for i := 0; i < 10; i++ {
        tasks <- Task{i, i * i}
    }

    // 关闭接收通道
    close(tasks)

    // 从发送通道接收结果
    for i := 0; i < 10; i++ {
        result := <- results
        fmt.Println(result)
    }
}

type Task struct {
    ID int
    Data int
}

type Result struct {
    TaskID int
    Square int
}

func worker(tasks chan Task, results chan Result) {
    for task := range tasks {    // 从接收通道接收任务
        square := task.Data * task.Data
        result := Result{task.ID, square}
        results <- result    // 发送结果到发送通道
    }
}

3. 使用WaitGroup等待所有Goroutines完成：当启动多个Goroutines时，我们需要确保主Goroutine在所有子Goroutines完成后才退出。可以使用sync.WaitGroup来实现这一目标。在每个子Goroutine中，使用wg.Done()告知WaitGroup当前Goroutine已完成。在主Goroutine中，调用wg.Wait()Ce qui suit est un exemple d'extrait de code qui montre comment contrôler le nombre de Goroutines :
   

var wg sync.WaitGroup

func main() {
    wg.Add(2)

    // 启动两个Goroutines
    go work("Goroutine 1")
    go work("Goroutine 2")

    // 主Goroutine等待所有子Goroutines执行完成
    wg.Wait()
}

func work(name string) {
    defer wg.Done()
    
    // 模拟一些工作
    time.Sleep(time.Second * 2)
    fmt.Println(name, "完成工作")
}

Utiliser des canaux pour la communication entre les Goroutines : les canaux sont le principal mécanisme de transfert de données entre les Goroutines. Un modèle courant consiste à utiliser un canal de réception et un canal d'envoi pour interagir. Le canal de réception est utilisé pour recevoir des tâches, tandis que le canal d'envoi est utilisé pour renvoyer les résultats du traitement.

Ce qui suit est un exemple de code simple qui montre comment utiliser les canaux de communication entre les Goroutines :


rrreee

Utilisez WaitGroup pour attendre que toutes les Goroutines se terminent : lors du démarrage de plusieurs Goroutines, nous devons nous assurer que le Goroutine principal ne quitte qu'une fois tous les Goroutines enfants terminés. Vous pouvez utiliser sync.WaitGroup pour y parvenir. Dans chaque Goroutine enfant, utilisez wg.Done() pour indiquer au WaitGroup que le Goroutine actuel est terminé. Dans le Goroutine principal, appelez wg.Wait() pour attendre que tous les Goroutines enfants se terminent.

Ce qui suit est un exemple de code simple qui montre comment utiliser WaitGroup pour attendre que tous les Goroutines soient terminés :


rrreee
IV Résumé

Cet article partage l'expérience pratique de l'utilisation de Goroutines pour créer des serveurs hautes performances et donne un exemple de code correspondant. . L'utilisation de Goroutines pour la programmation simultanée peut nous aider à utiliser pleinement les processeurs multicœurs pour obtenir des performances plus efficaces. Dans les applications réelles, certaines optimisations et ajustements doivent être effectués en fonction de circonstances spécifiques pour obtenir les meilleurs résultats de performances. 🎜🎜Ce qui précède est un partage sur la façon d'utiliser Goroutines pour créer des serveurs hautes performances. J'espère que cela sera utile aux lecteurs. Si vous développez un projet Golang, vous pouvez aussi bien essayer d'utiliser Goroutines pour implémenter une programmation simultanée afin d'améliorer les performances du serveur. 🎜🎜Références : 🎜[1] Site Web Go Language Chinese. : Programmation simultanée de threads légers https://studygolang.com/articles/25926🎜[2] Go Language Concurrency Sync https : //www.imooc.com/article/details/id/25497🎜

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!