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

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

WBOY

Libérer： 2023-07-17 18:22:37

original

785 Les gens l'ont consulté

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 :

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.
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.
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

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()
}

Copier après la connexion

使用通道（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    // 发送结果到发送通道
    }
}

Copier après la connexion

使用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, "完成工作")
}

Copier après la connexion

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

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.

rrreee
IV Résumé

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!