Comment annuler le travail de chaîne en fonction de l'ID dans Golang

Dans Golang, l'annulation des tâches de chaîne est une exigence courante. Lorsque nous traitons de tâches simultanées, nous devons parfois annuler la tâche en cours d'exécution en fonction de l'ID de la tâche. Alors, comment implémenter cette fonction dans Golang ? Ci-dessous, je vais vous présenter une méthode simple et efficace. Tout d’abord, nous devons créer un canal tampon pour stocker l’ID de la tâche. Nous pouvons ensuite utiliser une instruction select pour écouter l'opération de lecture du canal et envoyer l'ID de la tâche au canal lorsque la tâche doit être annulée. Ensuite, dans la fonction d'exécution de tâche, nous pouvons déterminer si la tâche doit être annulée en jugeant si le canal est fermé. Si le canal est fermé, la tâche a été annulée et nous pouvons terminer l'exécution de la tâche à l'endroit approprié. De cette façon, nous pouvons facilement annuler les tâches de chaîne en fonction de l'ID dans Golang. Ce qui précède est la méthode introduite par l'éditeur php Xinyi, j'espère qu'elle sera utile à tout le monde !

Contenu des questions

J'en ai donc une post 端点，它创建一个作业并将它们添加到一个 chan 中。 workerjobschan = make(chan job, maxqueuesize)

Voici comment je fais mon travail dans la chaîne (main.go) :

for i := 1; i <= maxworkers; i++ {
    go func(i int) {
        for job := range workerjobschan {
            ctx, cancel := context.withcancel(context.background())
            storejob(job.search.id, cancel)
            job.execute(ctx, c.db, i)
        }
    }(i)
}

Je stocke la fonction d'annulation dans la carte : canceljobfuncs = make(map[int]context.cancelfunc).

Voici la fonction du poste :

func (j *job) execute(ctx context.context, db *sql.db, workerid int) error {


    for {
        select {
        // check for cancellation signal
        case <-ctx.done():
             if err := ctx.err(); err != nil {
                fmt.println("worker", workerid, "error", err)
             }
            fmt.println("worker", workerid, "cancelled")
            return nil

        default:
            fmt.printf("worker%d: processing %s\n", workerid, j.search.query)
            time.sleep(2 * time.second)
            fmt.printf("worker%d: active %s\n", workerid, j.search.query)
            time.sleep(5 * time.second)
            fmt.printf("worker%d: completed %s!\n", workerid, j.search.query)

        }
    }
}

J'annule le contexte (dans le gestionnaire http) comme ceci :

cancelJob(search.ID)

Mais le travail continue de fonctionner. J'ai essayé beaucoup de choses mais je n'arrive pas à le faire fonctionner.

Solution de contournement

Voici une façon d'illustrer un point évident : si votre code ne vérifie pas ctx.done(), il n'a aucun moyen de savoir qu'il a été annulé.
(BTW, c'est une autre paraphrase de ce que @jimb a écrit dans le commentaire sur votre question).

Donc, lorsque le code de la méthode .execute(...) commence à exécuter ce bloc :

fmt.printf("worker%d: processing %s\n", workerid, j.search.query)
    time.sleep(2 * time.second)
    fmt.printf("worker%d: active %s\n", workerid, j.search.query)
    time.sleep(5 * time.second)
    fmt.printf("worker%d: completed %s!\n", workerid, j.search.query)

Il atteindra la fin du bloc (7 secondes). Il n'y a aucune instruction lui disant de s'arrêter en cas d'annulation.

Si vous souhaitez que votre fonction puisse détecter une annulation lors d'une instruction "veille", vous devez changer votre code.

Voici un exemple de la façon de procéder en utilisant votre exemple :

func (j *job) execute(ctx context.context, db *sql.db, workerid int) error {


    for {
        fmt.printf("worker%d: processing %s\n", workerid, j.search.query)

        // rewrite time.sleep() with time.after() so that it can be composed
        // in a select statement:
        select {
        case <-ctx.done():
            fmt.println("worker", workerid, "cancelled")
            return nil
        case <-time.after(2 * time.second):
            // keep going
        }

        fmt.printf("worker%d: active %s\n", workerid, j.search.query)

        select {
        case <-ctx.done():
            fmt.println("worker", workerid, "cancelled")
            return nil
        case <-time.after(5 * time.second):
            // keep going
        }

        fmt.printf("worker%d: completed %s!\n", workerid, j.search.query)
    }
}

//m.sbmmt.com/link/3bc31a430954d8326605fc690ed22f4d

Je suppose que votre code actuel n'a pas time.sleep() 指令，而是 processsearch(...) 或 doquery(...) ou ...

Si vous avez besoin que ces fonctions puissent être annulées pendant l'exécution, vous devez leur transmettre le contexte d'annulation d'une manière ou d'une autre et leur demander de vérifier l'annulation d'une manière ou d'une autre.

Une façon de "passer le contexte" est évidemment de l'ajouter aux paramètres de ladite fonction :

processsearch(ctx, ...)
doquery(ctx, ...)

Mais en fonction de votre code existant, certains paramètres peuvent déjà avoir des méthodes intégrées pour annuler.
Par exemple :

// an http.Request carries a context:
func doQuery(req *http.Request, ....) {
    ...
}

// at call site:
    ...
    req := http.NewRequestWithContext(ctx, "GET", "https://some.other.service/", nil)
    doQuery(req, ...)

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!