La réponse est d'implémenter le mode de pool de travailleurs en utilisant le canal et le goroutine pour contr?ler le nombre de taches par lots simultanées et efficaces. 1. Définissez la structure du travail et des résultats des résultats de la tache; 2. Créer un canal de tache tampon et un canal de résultat; 3. Démarrez un nombre fixe de goroutines de travailleur, chaque travailleur lit la tache à partir du canal des travaux et écrit le canal des résultats, et appelle wg.done () après l'achèvement; 4. Le Goroutine principal envoie toutes les taches et ferme le canal des travaux; 5. Utilisez Sync.WaitGroup pour attendre que tous les travailleurs se terminent et ferme le canal de résultats dans le Goroutine; 6. Le Goroutine principal recueille les résultats à partir de résultats pour compter le nombre de succès et de défaillances. Ce mode empêche l'épuisement des ressources en limitant le nombre de Goroutines, convient au traitement des taches par lots, et peut être étendu et optimisé en ajoutant des délais de contexte, des mécanismes de réessayer, etc. Le programme final sort correctement les résultats de traitement et quitte en toute sécurité.

En Go, Worker Pool est un modèle de concurrence commun qui est utilisé pour gérer efficacement un grand nombre de taches tout en limitant le nombre de Goroutines fonctionnant simultanément et en évitant l'épuisement des ressources. Il est très adapté à la gestion des taches par lots telles que le traitement de fichiers, les demandes de réseau, le nettoyage des données, etc.

Ce qui suit est un exemple concret pour démontrer comment implémenter un pool de travailleurs simple en utilisant Go.

? ? Scénario: traitez un lot de taches (comme le téléchargement des URL)

Supposons que nous ayons 100 taches (telles que les demandes HTTP), mais nous voulons seulement exécuter 10 goroutines en même temps pour gérer ces taches pour éviter la surcharge du système.

? Structure centrale

• Un canal jobs
• Plusieurs travailleurs (goroutines)
• Une file d'attente de résultats (canal results )
• Attendez que toutes les taches se terminent ( sync.WaitGroup )

? Exemple de code complet

 package principal

importer (
    "FMT"
    "Math / Rand"
    "sync"
    "temps"
)

// Tache Type Type Job Struct {
    Id int
}

// Type de structure de résultat struct {
    Jobid int
    Success bool
    Cha?ne de message
}

Func Worker (id int, jobs <-chan Job, résultats chan <- résultats, wg * sync.waitgroup) {
    différer wg.done ()
    pour le travail: = emplois de plage {
        fmt.printf ("Worker% d a commencé Job% d \ n", id, job.id)

        // Simuler des opérations longues (telles que les demandes de réseau)
        Time.Sleep (time.Duration (rand.intn (1000)) * time.millisecond)

        Succès: = rand.float32 ()> 0,3 // 70% Taux de réussite Var Msg String
        Si le succès {
            msg = "traité avec succès"
        } autre {
            msg = "a échoué"
        }

        résultats <- résultats {
            Jobid: job.id,
            Succès: succès,
            Message: msg,
        }
        FMT.PRINTF ("Worker% D a terminé Job% D \ n", id, Job.id)
    }
}

func main () {
    consommer numjobs = 100
    consommer des nums = 10

    Emplois: = Make (Chan Job, numjobs)
    Résultats: = Make (Résultats chan, numjobs)

    var wg sync.waitgroup

    // 1. Démarrer les travailleurs
    pour i: = 1; i <= numworkers; je {
        wg.add (1)
        Go Worker (I, emplois, résultats et WG)
    }

    // 2. Envoyez la tache pour i: = 1; i <= numjobs; je {
        Jobs <- Job {id: i}
    }
    Fermer (emplois) // Fermer le canal des travaux, indiquant qu&#39;il n&#39;y a plus de taches // 3. Attendez que tous les travailleurs se terminent dans un autre goroutine, puis fermer les résultats
    aller func () {
        wg.wait ()
        Fermer (résultats)
    } ()

    // 4. Collectez les résultats avec succès: = 0
    échec: = 0
    Pour le résultat: = Résultats de la plage {
        Si résultat.success {
            Réussi  
        } autre {
            échoué  
        }
        // Facultatif: imprimez ou enregistrez le résultat // fmt.printf ("Job% d:% s \ n", result.jobid, result.sessage)
    }

    fmt.printf ("Traitement complet. Succès:% d, échec:% d \ n", réussi, échoué)
}

? Description des points clés

? jobs et results utilisent le canal tamponné

• jobs := make(chan Job, numJobs) : Tampon le canal pour éviter d'envoyer un blocage
• Il ne peut pas non plus tamponner, mais lors de l'envoi de taches, assurez-vous qu'un travailleur le re?oit.

? après close(jobs) , range jobs quitteront automatiquement

• Tous les travailleurs for job := range jobs se termineront naturellement après la fermeture du canal

? Utilisez sync.WaitGroup pour attendre que tous les travailleurs sortent

• Chaque travailleur complète wg.Done()
• Le goroutine principal ferme results après avoir attendu l'achèvement pour empêcher range results de la mort

? results doivent également être fermés

• Sinon, for range results se bloquera pour toujours

? Optimisation évolutive

• Mécanisme d'erreur de réessayer : ajoutez la logique de réessayer au travailleur
• Contr?le du délai d'attente : utilisez context.WithTimeout
• Numéro de travailleur dynamique : ajustez en fonction de la charge
• Fituration de tache prioritaire : utilisez plusieurs canaux ou files d'attente prioritaires

? Scénarios applicables

• Traitement par lots des fichiers ou enregistrements de base de données
• Rampage simultané des pages Web
• Email Envoyer la file d'attente
• Transcodage d'image / vidéo
• Traitement du journal

Fondamentalement, c'est tout. Le canal de Go's Goroutine rend la mise en ?uvre de la piscine des travailleurs très simple et intuitive. La clé consiste à comprendre l'utilisation de l'arrêt et du groupe d'attente pour éviter les blocs de bloces ou les fuites.

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!