Dans le modèle de développement synchrone traditionnel, lorsque nous appelons une fonction, les données sont transmises via les paramètres de la fonction et le résultat final du calcul est renvoyé via la valeur de retour de la fonction. Cependant, dans le mode de développement asynchrone multithread, la transmission et le retour des données sont très différents du mode de développement synchrone. Étant donné que l'exécution et la fin des threads sont imprévisibles, lors du transfert et du renvoi de données, les données ne peuvent pas être renvoyées via les paramètres de fonction et les instructions de retour comme les fonctions. Cet article présente plusieurs méthodes pour transmettre des données aux threads pour les raisons ci-dessus. Dans le prochain article, nous présenterons les méthodes de renvoi des données à partir des threads.
Si vous voulez le prendre en premier, vous devez d'abord le donner. Généralement, lorsque vous utilisez des threads, vous avez besoin de données d'initialisation, puis le thread utilise ces données pour traiter et renvoyer les résultats. La première chose à faire dans ce processus est de transmettre les données au thread.
1. Transmettre les données via les méthodes du constructeur
Lors de la création d'un thread, vous devez créer une instance de la classe Thread ou de sa sous-classe. Par conséquent, il n'est pas difficile pour nous de penser à transmettre des données dans le thread via la méthode constructeur de la classe thread avant d'appeler la méthode start. Et enregistrez les données entrantes à l'aide de variables de classe pour une utilisation par le thread (actuellement utilisé dans la méthode run). Le code suivant montre comment transmettre des données via le constructeur :
Copiez le code comme suit :
mythread du paquet ;
la classe publique MyThread1 étend Thread
{
nom de chaîne privé ;
public MyThread1 (nom de la chaîne)
{
this.name = nom ;
}
exécution publique vide()
{
System.out.println("bonjour " + nom);
}
public static void main (String[] arguments)
{
Fil de discussion = new MyThread1("monde");
thread.start();
}
}
Étant donné que cette méthode transfère les données lors de la création de l'objet thread, les données sont déjà en place avant l'exécution du thread, de sorte qu'elles ne seront pas transmises après l'exécution du thread. Si vous souhaitez transmettre des données plus complexes, vous pouvez utiliser des structures de données telles que des collections et des classes. Bien qu'il soit plus sûr d'utiliser la méthode constructeur pour transférer des données, cela entraînera de nombreux inconvénients s'il y a beaucoup de données à transférer. Étant donné que Java n'a pas de paramètres par défaut, si vous souhaitez obtenir des effets similaires aux paramètres par défaut, vous devez utiliser la surcharge. Cela rend non seulement le constructeur lui-même trop complexe, mais augmente également considérablement le nombre de constructeurs. Par conséquent, pour éviter cette situation, transmettez les données via des méthodes de classe ou des variables de classe.
2. Transmettre les données via des variables et des méthodes
Il existe généralement deux possibilités pour transmettre des données dans un objet. La première consiste à transmettre les données via la méthode constructeur lors de la création de l'objet. L'autre possibilité consiste à définir une série de méthodes ou de variables publiques dans la classe (également appelées). un champ). Ensuite, après avoir créé l'objet, attribuez les valeurs une par une via les instances d'objet. Le code suivant est une modification de la classe MyThread1, utilisant une méthode setName pour définir la variable name :
Copiez le code comme suit :
mythread du paquet ;
la classe publique MyThread2 implémente Runnable
{
nom de chaîne privé ;
public void setName (nom de la chaîne)
{
this.name = nom ;
}
exécution publique vide()
{
System.out.println("bonjour " + nom);
}
public static void main (String[] arguments)
{
MonThread2 monThread = new MyThread2();
monThread.setName("monde");
Fil de discussion = nouveau Thread(monThread);
thread.start();
}
}
3. Transmettez les données via la fonction de rappel
Les deux méthodes de transmission de données aux threads décrites ci-dessus sont les plus couramment utilisées. Mais les deux méthodes transmettent activement les données à la classe thread dans la méthode principale. Pour les threads, ces données sont reçues passivement. Cependant, dans certaines applications, il est nécessaire d'obtenir des données de manière dynamique pendant l'exécution du thread. Par exemple, trois nombres aléatoires sont générés dans la méthode d'exécution du code suivant, puis la somme de ces trois nombres aléatoires est calculée via la méthode de traitement. de la classe Work, et renvoie le résultat via la valeur de la classe Data. Comme le montre cet exemple, trois nombres aléatoires doivent être obtenus avant de renvoyer la valeur. En d’autres termes, cette valeur ne peut pas être transmise à l’avance à la classe thread.
Copiez le code comme suit :
mythread du paquet ;
Données de classe
{
valeur int publique = 0 ;
}
travail en classe
{
processus de vide public (données de données, nombres entiers)
{
pour (int n : nombres)
{
data.value += n;
}
}
}
la classe publique MyThread3 étend Thread
{
travail privé;
public MyThread3 (Travail travail)
{
this.work = travail ;
}
exécution publique vide()
{
java.util.Random random = new java.util.Random();
Données données = nouvelles données ();
int n1 = random.nextInt(1000);
int n2 = random.nextInt(2000);
int n3 = random.nextInt(3000);
work.process(data, n1, n2, n3); // Utiliser la fonction de rappel
System.out.println(String.valueOf(n1) + "+" + String.valueOf(n2) + "+"
+ String.valueOf(n3) + "=" + data.value);
}
public static void main (String[] arguments)
{
Fil de discussion = new MyThread3(new Work());
thread.start();
}
}
La méthode de traitement dans le code ci-dessus est appelée fonction de rappel. Essentiellement, les fonctions de rappel sont des fonctions événementielles. Dans l'API Windows, les fonctions de rappel sont souvent utilisées pour interagir avec les données entre le programme appelant l'API. Par conséquent, le processus d’appel de la fonction de rappel est le processus original de déclenchement de l’événement. Dans cet exemple, appeler la méthode process pour obtenir des données équivaut à déclencher un événement dans la méthode run.