Pourquoi getObject prend-il plus de temps lorsque la taille du fichier est définie dynamiquement et stockée en mémoire dans aws-sdk-go ?

Lorsque nous utilisons aws-sdk-go pour les opérations sur les fichiers, nous devons parfois définir dynamiquement la taille du fichier et le stocker en mémoire. Cependant, lorsque nous utilisons la méthode getObject pour obtenir ce fichier, nous pouvons constater que le temps d'acquisition est plus long. En effet, dans aws-sdk-go, la méthode getObject est basée sur le protocole HTTP et le protocole HTTP nécessite plus de temps et de ressources pour la transmission de fichiers volumineux. Par conséquent, lorsque nous définissons la taille du fichier de manière dynamique et que nous le stockons en mémoire, le temps d'exécution de la méthode getObject peut s'allonger. Afin de réduire l'apparition de cette situation, nous pouvons envisager d'utiliser d'autres méthodes plus adaptées au transfert de fichiers volumineux, comme les téléchargements segmentés ou l'utilisation de téléchargements multithread.

Contenu de la question

J'essaie de comprendre ForkJoinPool. En fait, je ne comprends pas quoi faire dans le cas de fork 方法在没有 join et de la condition finale. Si fork envoie une tâche à exécuter dans une file d'attente, alors pourquoi ce code ne s'exécute-t-il pas à l'infini ?

import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.RecursiveAction;

public class Main {

    public static void main(String[] args) {
        ForkJoinPool pool = new ForkJoinPool();
        pool.invoke(new Test());
    }

    static class Test extends RecursiveAction {

        @Override
        protected void compute() {
            System.out.println(Thread.currentThread().getName());
            Test test = new Test();
            test.fork();
        }
    }
}

Les résultats sont toujours différents.

Deuxième question : Que se passe-t-il si vous vous appelez self fork dans un calcul ?

@Override
protected void compute() {
      System.out.println(1);
      fork();
}

Le calcul sera appelé 1 ou 2 fois.

Ou ceci :

protected void compute() {
      System.out.println(1);
      fork();
      join();
}

Le calcul sera appelé plusieurs fois puis s'arrêtera.

Solution de contournement

Cela s'exécute à l'infini, mais ils threads démons n'empêchent pas la JVM de s'arrêter, ils s'arrêtent donc une fois le thread principal terminé (c'est-à-dire immédiatement). Configurez une boucle infinie qui empêche le thread principal de se terminer et vous verrez votre tâche se poursuivre indéfiniment.

public static void main(String[] args) {
    ForkJoinPool pool = new ForkJoinPool();
    pool.invoke(new Test());
    while (true) {}
}

static class Test extends RecursiveAction {

    @Override
    protected void compute() {
        System.out.println(Thread.currentThread().getName());
        Test test = new Test();
        test.fork();
    }
}

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!