Créer deux fils, l'un affichage bizarre & autres numéros
Je suis en train de créer deux fils, l'un thread d'affichage même des nombres entiers de 0 à 10, un thread d'affichage des entiers impairs de 1 à 11. Est le code suivant adapté pour la conception de ce programme?
public class Mythread {
public static void main(String[] args) {
Runnable r = new Runnable1();
Thread t = new Thread(r);
t.start();
Runnable r2 = new Runnable2();
Thread t2 = new Thread(r2);
t2.start();
}
}
class Runnable2 implements Runnable{
public void run(){
for(int i=0;i<11;i++){
if(i%2 == 1)
System.out.println(i);
}
}
}
class Runnable1 implements Runnable{
public void run(){
for(int i=0;i<11;i++){
if(i%2 == 0)
System.out.println(i);
}
}
}
- Faut-il faire ce que vous voulez? Si oui, alors je suppose que c'est adapté...
- Avez-vous l'exécuter?
- Si vous êtes en comparant comment/quand les threads s'exécutent, il serait mieux d'appeler le Thread.start() méthodes immédiatement les uns après les autres. Déplacer
t.start();
vers le bas, juste au-dessus det2.start();
- oui je le lance et il fonctionne très bien mais il n'est pas sûr que c'est la meilleure façon de la mettre en œuvre
Vous devez vous connecter pour publier un commentaire.
Je voudrais juste changer quelques détails (pas besoin d'utiliser l'opérateur modulo ici...):
@aymeric répondre à l'habitude d'imprimer les numéros dans leur ordre naturel, mais ce code. Explication à la fin.
Afin d'atteindre ainsi, les méthodes des deux threads ci-dessus doivent être appelés l'un après l'autre, c'est à dire qu'ils doivent être synchronisés et je suis atteinte de l'utilisation de verrous.
Le code fonctionne comme ceci: t1.exécuter imprime le nombre impair et notifie les thread en attente qu'il va libérer le verrou, puis s'en va dans un état d'attente.
À ce stade t2.run est invoqué, il imprime la prochaine même nombre, informe les autres threads qu'il est sur le point de libérer le verrou qu'il détient et passe alors en état d'attente.
Cela continue jusqu'à l'itr dans t2.run() atteint 50, à ce stade, notre objectif a été atteint et nous avons besoin de tuer ces deux threads.
Par la rupture, j'évite d'appel de verrouillage.wait() dans t2.exécuter et t2 thread est donc à l'arrêt, le contrôle va maintenant aller à t1.exécuter, car il a été en attente pour acquérir de la serrure; mais ici itr valeur sera > 51 et nous allons sortir de son run(), donc arrêter le fil.
Si la pause n'est pas utilisé dans t2.run(), mais nous allons voir les numéros de 1 à 50 sur l'écran, mais les deux fils se met dans une situation de blocage et de continuer à être en état d'attente.
oddT.start(); if(oddT.isAlive()){ evenT.start(); } oddT.join(); evenT.join();
Oui, c'est bien. Mais dans ce cas, je ne pense pas que vous avez besoin de 2 fils sont tous, parce que l'opération est simple. Toutefois, si vous pratiquez les fils, il est OK
Ci-dessous est le code qui utilise verrou sur un objet partagé qui a le nombre à être imprimé. Il garantit la séquence de plus, contrairement à la solution ci-dessus.
La sortie ressemblera à:
t1--1
t2--2
t1--3
t2--4
t1--5
t2--6
t1--7
t2--8
t1--9
t2--10
fait t2
fait t1
Je voudrais aussi regarder à l'aide de Java Simultanéité si vous voulez des solutions de rechange. Certaines des fonctionnalités fournies dans le Java Simultanéité package offre un niveau d'abstraction plus élevé, puis à l'aide de la classe Thread directement et de fournir plus de fonctionnalités comme un résultat.
Pour votre cas spécifique de ce que vous faites est tout à fait raisonnable, cependant, est de l'ordre de l'impression de ces numéros important? Voulez-vous evens avant cote? Ces sortes de questions permettrait de mieux indiquer le design qui correspond le mieux à vos besoins.
Simultanées Package:
Pas la réponse pour le problème ci-dessus, mais sur les mêmes lignes.
Programme pour imprimer les éléments du tableau de manière séquentielle mais l'utilisation de deux threads différents pour imprimer les éléments adjacents
Nos sera imprimé dans la séquence
package p.Les Threads;
Puis d'appeler la classe ci-dessus comme ceci
sortie:
public class ConsecutiveNumberPrint {
}
De SORTIE :-
cote de 1
cote 3
cote 5
cote 7
cote 9
evens 2
evens 4
evens 6
evens 8
Peu près tout ce qui est nécessaire si l'on vous demande d'imprimer même nombre impair de façon synchronisée.
La Question devrait être: Impression Bizarre-Même les Numéros simultanément à l'Aide de Threads