Exemple de partage de code de deux méthodes de création de threads en Java

Cet article présente principalement en détail les deux méthodes de création de threads en Java et des exemples pertinents. Les amis dans le besoin peuvent se référer à

Deux méthodes de création de threads en Java

<.>Java fournit la classe de thread Thread pour créer des programmes multithread. En fait, l'opération de création d'un thread est la même que celle d'un objet de classe ordinaire, et un thread est un objet instance de la classe Thread ou de sa sous-classe. Chaque objet Thread décrit un thread distinct. Pour générer un thread, il existe deux méthodes :

◆Vous devez dériver une nouvelle classe de thread à partir de la classe Java.lang.Thread et surcharger sa méthode run()

 ; ◆Implémentez l'interface Runnalbe

et surchargez la méthode run() dans l'interface Runnalbe.

Pourquoi Java propose-t-il deux méthodes pour créer des threads ? Quelles sont les différences entre eux ? En comparaison, quelle méthode est la meilleure ?

En Java, les classes ne prennent en charge que l'héritage unique, c'est-à-dire que lors de la définition d'une nouvelle classe, elle ne peut étendre qu'une seule classe externe. De cette façon, si vous créez une classe de thread personnalisée, elle est implémentée par. étendre la méthode de la classe Thread, de sorte que cette classe personnalisée ne peut pas étendre d'autres classes et ne peut pas implémenter de fonctions plus complexes. Par conséquent, si une classe personnalisée doit étendre d'autres classes, vous pouvez utiliser la méthode qui implémente l'interface Runnable pour définir la classe en tant que classe de thread, évitant ainsi les limitations de l'héritage unique Java.

La chose la plus importante est que les threads créés en implémentant l'interface Runnable peuvent traiter la même ressource, réalisant ainsi le partage des ressources

(1) En étendant la classe Thread Create multi-. fils de discussion

Supposons qu'un théâtre dispose de trois points de vente de billets, qui sont utilisés pour vendre des billets aux enfants, aux adultes et aux personnes âgées. Le théâtre dispose de 100 billets de cinéma pour chaque fenêtre, qui sont des billets pour enfants, des billets pour adultes et des billets pour les seniors. Trois fenêtres doivent vendre des billets en même temps, et il n'y a désormais qu'un seul vendeur de billets. Ce vendeur de billets équivaut à un processeur, et trois fenêtres équivalent à trois threads. Jetons un coup d'œil à la manière dont ces trois threads sont créés via le programme.

public class MutliThreadDemo {
 public static void main(String [] args){
  MutliThread m1=new MutliThread("Window 1");
  MutliThread m2=new MutliThread("Window 2");
  MutliThread m3=new MutliThread("Window 3");
  m1.start();
  m2.start();
  m3.start();
 }
}
class MutliThread extends Thread{
 private int ticket=100;//每个线程都拥有100张票
 MutliThread(String name){
  super(name);//调用父类带参数的构造方法
 }
 public void run(){
  while(ticket>0){
   System.out.println(ticket--+" is saled by "+Thread.currentThread().getName());
  }
 }
}

Une classe thread est définie dans le programme, qui étend la classe Thread. Utilisez la classe thread étendue pour créer trois objets thread dans la méthode principale de la classe MutliThreadDemo et démarrez-les respectivement via la méthode start().

Comme vous pouvez le voir sur les résultats, chaque fil correspond à 100 billets de cinéma, et il n'y a aucune relation entre eux, cela signifie que chaque fil est égal et n'a pas de relation prioritaire, ils ont donc tous des opportunités d'obtenir. traitées par le CPU. Cependant, les résultats montrent que ces trois threads ne sont pas exécutés alternativement en séquence, mais lorsque les trois threads sont exécutés en même temps, certains threads ont plus de chances de se voir attribuer des tranches de temps, et les billets sont vendus à l'avance, tandis que d'autres les discussions se voient attribuer du temps. Il y a moins d’occasions de filmer et les billets seront vendus plus tard.

On peut voir que

plusieurs threads créés en étendant la classe Thread exécutent le même code, mais ils sont indépendants les uns des autres et chacun a ses propres ressources sans interférer les uns avec les autres.

(2) Créer des multi-threads en implémentant l'interface Runnable

public class MutliThreadDemo2 {
 public static void main(String [] args){
  MutliThread m1=new MutliThread("Window 1");
  MutliThread m2=new MutliThread("Window 2");
  MutliThread m3=new MutliThread("Window 3");
  Thread t1=new Thread(m1);
  Thread t2=new Thread(m2);
  Thread t3=new Thread(m3);
  t1.start();
  t2.start();
  t3.start();
 }
}
class MutliThread implements Runnable{
 private int ticket=100;//每个线程都拥有100张票
 private String name;
 MutliThread(String name){
  this.name=name;
 }
 public void run(){
  while(ticket>0){
   System.out.println(ticket--+" is saled by "+name);
  }
 }
}

Étant donné que ces trois threads sont également indépendants les uns des autres, chacun a son propres ressources. Cela représente 100 billets de cinéma, donc le résultat produit par le programme est similaire au résultat (1). Chaque thread traite ses propres 100 tickets indépendamment sans s'affecter les uns les autres.

On peut voir que tant que la situation réelle exige que les nouveaux threads soient indépendants les uns des autres, aient leurs propres ressources et n'interfèrent pas les uns avec les autres, n'importe quelle méthode peut être utilisée pour créer des multi- fils. Parce que les programmes multithread créés de ces deux manières peuvent remplir la même fonction.

Étant donné que ces trois fils de discussion sont indépendants les uns des autres et que chacun possède ses propres ressources, à savoir 100 tickets de cinéma, les résultats générés par le programme sont similaires à ceux de l'exemple 4.2.1. Chaque thread traite ses propres 100 tickets indépendamment sans s'affecter les uns les autres.

On peut voir que tant que la situation réelle exige que les nouveaux threads soient indépendants les uns des autres, aient leurs propres ressources et n'interfèrent pas les uns avec les autres, n'importe quelle méthode peut être utilisée pour créer des multi- fils. Parce que les programmes multithread créés de ces deux manières peuvent remplir la même fonction.

(3) Réaliser le partage de ressources entre les threads en implémentant l'interface Runnable

Cette situation existe également dans la réalité, comme par exemple pour simuler le système de billetterie d'une gare If. Il n'y a que 100 billets de train envoyés du point A au point B ce jour-là, et toutes les fenêtres sont autorisées à vendre ces 100 billets, alors chaque fenêtre est également équivalente à un fil, mais la différence par rapport à l'exemple précédent est que tout le traitement des fils La ressource est la même ressource, soit 100 tickets. Si l'on utilise toujours la méthode précédente pour créer des threads, c'est évidemment impossible à réaliser. Comment gérer cette situation ? Regardez le programme ci-dessous. Le code du programme est le suivant :

public class MutliThreadDemo3 {
 public static void main(String [] args){
  MutliThread m=new MutliThread();
  Thread t1=new Thread(m,"Window 1");
  Thread t2=new Thread(m,"Window 2");
  Thread t3=new Thread(m,"Window 3");
  t1.start();
  t2.start();
  t3.start();
 }
}
class MutliThread implements Runnable{
 private int ticket=100;//每个线程都拥有100张票
 public void run(){
  while(ticket>0){
   System.out.println(ticket--+" is saled by "+Thread.currentThread().getName());
  }
 }
}

Comme analysé ci-dessus, le programme ne crée qu'une seule ressource dans la mémoire, et les trois threads nouvellement créés sont tous basés sur l'accès à la même ressource. , et comme le même code s'exécute sur chaque thread, ils remplissent la même fonction.

On peut voir que si le problème réel nécessite la création de plusieurs threads pour effectuer la même tâche et que les plusieurs threads partageront la même ressource, alors vous pouvez créer un programme multithread en implémentant l'interface Runnable. . Cette fonction ne peut pas être obtenue en étendant la classe Thread. Les lecteurs y réfléchissent, pourquoi ?

L'implémentation de l'interface Runnable présente des avantages incomparables par rapport à l'extension de la classe Thread. Cette méthode est non seulement bénéfique pour la robustesse du programme, permettant au code d'être partagé par plusieurs threads, mais également les ressources de code et de données sont relativement indépendantes, ce qui est particulièrement adapté aux situations où plusieurs threads avec le même code traitent la même chose. ressource. De cette façon, les threads, le code et les ressources de données sont efficacement séparés, ce qui reflète bien l'idée de la programmation orientée objet. Par conséquent, presque tous les programmes multithreads sont complétés par l’implémentation de l’interface Runnable.

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!