Quelles sont les quatre méthodes de création de pool de threads ?

Méthodes : newCachedThreadPool crée un pool de threads pouvant être mis en cache, newFixedThreadPool crée un pool de threads de longueur fixe, newScheduledThreadPool crée un pool de threads de longueur fixe et newSingleThreadExecutor crée un pool de threads à un seul thread.

Quatre méthodes de création de pool de threads

Java fournit quatre threads via les exécuteurs Les pools sont :

1. Utilisez newCachedThreadPool

newCachedThreadPool pour créer un pool de threads pouvant être mis en cache si la longueur du pool de threads dépasse les besoins de traitement, les threads inactifs peuvent être recyclés de manière flexible. S'il n'y a pas de recyclage, créez un nouveau fil de discussion.

Les caractéristiques de ce type de pool de threads sont :

• Il n'y a quasiment aucune limite sur le nombre de threads de travail créés (en fait, il y a une limite, le le nombre est Interger. MAX_VALUE), cela peut ajouter de manière flexible des threads au pool de threads.

• Si aucune tâche n'est soumise au pool de threads pendant une longue période, c'est-à-dire si le thread de travail est inactif pendant la durée spécifiée (la valeur par défaut est 1 minute), le thread de travail le fera se termine automatiquement. Après la résiliation, si vous soumettez une nouvelle tâche, le pool de threads recréera un thread de travail.

• Lors de l'utilisation de CachedThreadPool, vous devez faire attention au contrôle du nombre de tâches. Sinon, en raison d'un grand nombre de threads exécutés en même temps, le système pourrait être paralysé.

L'exemple de code est le suivant :

 package test;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
   public class ThreadPoolExecutorTest {
   public static void main(String[] args) {
   ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
  for (int i = 0; i < 10; i++) {
   final int index = i;
    try {
    Thread.sleep(index * 1000);
    } catch (InterruptedException e) {
     e.printStackTrace();
    }
    cachedThreadPool.execute(new Runnable() {
     public void run() {
      System.out.println(index);
     }
    });
   }
  }
 }

2 Utilisez newFixedThreadPool

pour créer un pool de threads avec un spécifié. nombre de threads de travail. Chaque fois qu'une tâche est soumise, un thread de travail est créé. Si le nombre de threads de travail atteint le nombre maximum initial du pool de threads, la tâche soumise est stockée dans la file d'attente du pool.

FixedThreadPool est un pool de threads typique et excellent. Il présente les avantages d'un pool de threads, améliorant l'efficacité du programme et économisant les frais généraux lors de la création de threads. Cependant, lorsque le pool de threads est inactif, c'est-à-dire lorsqu'il n'y a aucune tâche exécutable dans le pool de threads, il ne libérera pas les threads de travail et occupera également certaines ressources système.

L'exemple de code est le suivant :

 package test;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 public class ThreadPoolExecutorTest {
  public static void main(String[] args) {
   ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
   for (int i = 0; i < 10; i++) {
    final int index = i;
    try {
     Thread.sleep(index * 1000);
    } catch (InterruptedException e) {
     e.printStackTrace();
    }
    cachedThreadPool.execute(new Runnable() {
     public void run() {
      System.out.println(index);
     }
    });
   }
  }
 }

Étant donné que la taille du pool de threads est de 3, chaque tâche est en veille pendant 2 secondes après la sortie de l'index, donc 3 nombres sont imprimés toutes les deux secondes.

Il est préférable de définir la taille du pool de threads de longueur fixe en fonction des ressources système telles que Runtime.getRuntime().availableProcessors().

3. Utilisez newSingleThreadExecutor

pour créer un exécuteur à thread unique, c'est-à-dire créer uniquement un thread de travail unique pour effectuer des tâches. thread. Pour exécuter des tâches, assurez-vous que toutes les tâches sont exécutées dans l’ordre spécifié (FIFO, LIFO, priorité). Si ce thread se termine anormalement, un autre le remplacera pour assurer une exécution séquentielle. La plus grande caractéristique d'un seul thread de travail est qu'il peut garantir que les tâches sont exécutées de manière séquentielle et qu'aucun thread multiple n'est actif à un moment donné.

L'exemple de code est le suivant :

package test;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class ThreadPoolExecutorTest {
 public static void main(String[] args) {
  ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();
  for (int i = 0; i < 10; i++) {
   final int index = i;
   singleThreadExecutor.execute(new Runnable() {
    public void run() {
     try {
      System.out.println(index);
      Thread.sleep(2000);
     } catch (InterruptedException e) {
      e.printStackTrace();
     }
    }
   });
  }
 }
}

4. Utilisez newScheduledThreadPool

pour créer un pool de threads de longueur fixe et prendre en charge les tâches planifiées et périodiques. Exécution, prenant en charge l’exécution des tâches planifiées et périodiques.

Retarde l'exécution de 3 secondes. L'exemple de code pour une exécution retardée est le suivant :

package test;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
public class ThreadPoolExecutorTest {
 public static void main(String[] args) {
  ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
  scheduledThreadPool.schedule(new Runnable() {
   public void run() {
    System.out.println("delay 3 seconds");
   }
  }, 3, TimeUnit.SECONDS);
 }
}

signifie qu'il sera exécuté toutes les 3 secondes après un délai de 1 seconde. est la suivante :

package test;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
public class ThreadPoolExecutorTest {
 public static void main(String[] args) {
  ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
  scheduledThreadPool.scheduleAtFixedRate(new Runnable() {
   public void run() {
    System.out.println("delay 1 seconds, and excute every 3 seconds");
   }
  }, 1, 3, TimeUnit.SECONDS);
 }
}

Plus Pour des connaissances liées à la programmation, veuillez visiter : Site Web d'apprentissage en programmation ! !

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!