Collaboration entre la fonction golang et goroutine

Dans la programmation Go, les fonctions et les goroutines travaillent ensemble pour obtenir la simultanéité. Une goroutine est créée dans une fonction, et les variables locales de la fonction sont visibles dans la goroutine. Goroutine peut être utilisé en combat réel pour des tâches de traitement simultanées, telles que le téléchargement simultané de fichiers. L'efficacité peut être améliorée en créant des goroutines responsables du téléchargement de différents fichiers. Lorsque vous utilisez goroutine, veuillez noter : créez une goroutine en quantité appropriée pour éviter une pénurie de ressources ; la goroutine n'a pas de valeur de retour et vous devez utiliser des primitives de concurrence pour obtenir des résultats. La goroutine ne peut pas être arrêtée ou annulée directement.

Coopération entre les fonctions Go et Goroutine

Dans le langage de programmation Go, goroutine est un mécanisme de concurrence qui peut créer des threads légers pour exécuter du code. Les fonctions et les goroutines travaillent ensemble pour réaliser une programmation simultanée efficace.

La connexion entre la fonction et Goroutine

Goroutine peut être créée à l'intérieur de la fonction, et les variables et constantes locales de la fonction sont visibles dans la goroutine. Lorsqu'une Goroutine se termine, ses variables et constantes locales seront recyclées.

L'exemple suivant montre comment créer une goroutine et transmettre des paramètres dans une fonction :

package main

import (
    "fmt"
    "time"
)

func printHello(name string) {
    fmt.Printf("Hello, %s!\n", name)
}

func main() {
    go printHello("World")
    time.Sleep(1 * time.Second)
}

Dans l'exemple ci-dessus, la fonction main crée une goroutine et passe le paramètre "World" . La goroutine exécute la fonction printHello et imprime "Hello, World!n". main 函数创建一个 goroutine 并传入参数"World"。goroutine 执行 printHello 函数，打印出 "Hello, World!n"。

实战案例：并发文件上传

考虑一个需要并发上传多个文件的用例：

package main

import (
    "context"
    "fmt"
    "io"
    "os"
    "path/filepath"
    "time"

    "cloud.google.com/go/storage"
)

func uploadFile(w io.Writer, bucketName, objectName string) error {
    ctx := context.Background()
    client, err := storage.NewClient(ctx)
    if err != nil {
        return fmt.Errorf("storage.NewClient: %v", err)
    }
    defer client.Close()

    f, err := os.Open(objectName)
    if err != nil {
        return fmt.Errorf("os.Open: %v", err)
    }
    defer f.Close()

    ctx, cancel := context.WithTimeout(ctx, time.Second*30)
    defer cancel()

    o := client.Bucket(bucketName).Object(objectName)
    wc := o.NewWriter(ctx)
    if _, err := io.Copy(wc, f); err != nil {
        return fmt.Errorf("io.Copy: %v", err)
    }
    if err := wc.Close(); err != nil {
        return fmt.Errorf("Writer.Close: %v", err)
    }
    fmt.Fprintf(w, "File %v uploaded to %v.\n", objectName, bucketName)
    return nil
}

func main() {
    bucketName := "bucket-name"
    objectNames := []string{"file1.txt", "file2.txt", "file3.txt"}

    for _, objectName := range objectNames {
        go uploadFile(os.Stdout, bucketName, objectName)
    }
}

在这个案例中，main

Cas pratique : téléchargement simultané de fichiers

Considérons un cas d'utilisation qui nécessite que plusieurs fichiers soient téléchargés simultanément :

rrreee

Dans ce cas, la fonction main crée une liste de goroutines, chaque goroutine du système d'exploitation Lisez un fichier et téléchargez-le sur Google Cloud Storage. Cela permet aux applications de télécharger plusieurs fichiers simultanément, améliorant ainsi considérablement les performances.

• Remarques
• Vous devez faire attention aux points suivants lorsque vous utilisez des goroutines :
• Les goroutines sont légères, il est donc facile de créer un grand nombre de goroutines. Assurez-vous de ne pas créer trop de goroutines et de priver le programme de ressources.

🎜Goroutine sort sans aucune valeur de retour. Si vous souhaitez obtenir les résultats d'une goroutine, utilisez des canaux ou d'autres primitives de concurrence. 🎜🎜Les goroutines sont anonymes, donc les goroutines individuelles ne peuvent pas être arrêtées ou annulées directement. 🎜🎜

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!