synchronisation des threads

Question

j'ai un problème de synchroniser trois threads(un serveur et 3 clients) chaque thread* appelle un autre thread**

alors 6 threads ;

*:emission des données(serveur).

**:reception des donnes(03 clients).

??????????

Ombitious_Developper · Answer

Salut:

Penses à utiliser un groupe de threads.

classe: ThreadGroup

Ou bien tu peux jouer sur le méthodes de la classe Thread pour arrêter un thread momenténemment puis de l'envoyer une notification pour s'activer, bien sûr ça devrait se faire suivant le schéma que tu traces (sorte de diagramme de synchronisation).

Attention au deadlock.


________________________________________________________________________________
A.B. : 
            "Dieu nous donne des mains, mais il ne bâtit pas les ponts

viphadia · Answer

merci 
mais c'est pas le cas!!!
l'appel  de ces trois threads se fait  dans une boucle while comme suit:
calcule(){
while(condition)
{
thread1;
thread2;
thread3;

}
}
et ça le probleme  tout ce boucle d'une manière infinie ????(l'execution des trois thread est incomplète donc la condition nechange pas);
j'ai utulisé join() pour que l'execution des trois threads se termine puis il teste la condition à nouveau mais ça marche pas dans la 2 ieme iteration????

Ombitious_Developper · Answer

Salut:

Comme tu l'avais décrit (un thread émetteur / un thread récepteur), c'est un peu comme la relation producteur/consommateur, je te conseille d'utiliser les sémaphores pour définir le plan d'exécution de tes threads concurrents.

Une petite connaissance des sémaphores va te permettre de régler ton problème.
Les sémaphores sont comme leurs nom l'indique des barrières qui:
- bloquent le passage
- ou autorisent le passage
devant un thread demandant un service ou l'entrée à une section critique.

De cette manière tu es sûr que tu bloques certains threads et d'autoriser le thread voulu, un fois ce dernier termine sa tâche il peut autoriser les autres à entrer à la section critique qui est comme tu l'as décrit la modification du boucle.

classe: java.util.concurrent.Semaphore

 		________________________________________________________________________________
A.B. : 
            "Dieu nous donne des mains, mais il ne bâtit pas les ponts

Ombitious_Developper · Answer

Salut:

Une autre solution:

Thread1:

thread2.wait ();
thread3.wait ();
//code thread 1
thread3.notify ();
thread2.notify ();




Thread2:






thread1.wait ();

thread3.wait ();
// code thread 2:
thread3.notify ();

thread1.notify ();











Thread3:




thread1.wait ();

thread2.wait ();
// code thread 3
thread2.notify ();

thread1.notify ();



________________________________________________________________________________
A.B. : 
            "Dieu nous donne des mains, mais il ne bâtit pas les ponts

viphadia · Answer

ok mais t'as aucune idée pour appler des threads dans une boucle?il me parait pas simple!!!!

Ombitious_Developper · Answer

Salut:

Thread th = new Thread ():

// Appel: début d'exécution
th.start ();


________________________________________________________________________________
A.B. : 
            "Dieu nous donne des mains, mais il ne bâtit pas les ponts

Ombitious_Developper · Answer

Salut:

Il y a une chose que je ne comprends pas. Pourquoi faire tous ces threads, on dirait que tu es en train d'écrire un programme client/serveur ordinaire.

Si oui, je pense qu'on peut résoudre le problème sans faire recoure à tout ce nombre de threads.


________________________________________________________________________________
A.B. : 
            "Dieu nous donne des mains, mais il ne bâtit pas les ponts

Ombitious_Developper · Answer

Salut:

Pourquoi Thread.suspend et Thread.resume sont [deprecated]?

La méthode Thread.suspend provoque toujours un interblocage. Si le thread cible 
détient un vérrou sur une ressource critique du système et quand ce dernier est
suspendu, alors aucun thread ne peut accèder à cette ressource jusqu'à ce que
le thread concerné est activé. Si ce thread essaye de vérouiller l'accès à cette resssource 
avant de s'activer [resume] alors un interblocage en resulte. On appelle ces les thread de cette situation 
[frozen processes].

C'est la traduction de ce que j'ai trouvé dans la documentation.


________________________________________________________________________________
A.B. : 
            "Dieu nous donne des mains, mais il ne bâtit pas les ponts

viphadia · Answer

salut 
c'est mon projet de fin d'études je suis en 5 ieme année informatique option intelligence artificielle mon  thème est " la tolérance aux pannes " l'architecture (client-serveur) 3clients et un seul serveur mais je developpe une application sur data mining le serveur décompose la bdd et envoie à chaque client une partie ,les clients effectuent des calculs et émissent les résultats au serveur et ce dernier fait des comparaison et des calculs et les renvoie aux clients et vice versa jusqu'à l'établissemet de toute règle associative possible;
dans le code de serveur j'ai 3 threads de reception et 3 d'émission chaque thread d'émission appel un threads de réception qui le convient et l'appel des threads d'emission dans main sera dans une boucle while et c'est ça mon problème???????
que je peux  faire alors

viphadia · Answer

Bonsoir,

Personne ne sait m'aider ?

viphadia · Answer

je suis besoin d'aide c'est urgent!

Ombitious_Developper · Answer

Salut:

Si tu veux exécuter les 3 threads successivement:

Thread1, puis Thread2, ensuite Thread3 et on recommence dès le début de telle sorte que chaque thread complète son exécution avant de donner la main au prochain thread.

Je pense que grâce à dieu, j'ai trouvé une solution qui consiste à enchaîner l'exécution des trois threads.

// 

TestThread
.java
public class TestThread {
    public static void main (String [] args) {
        Thread3 t3 = new Thread3 (null);
        Thread2 t2 = new Thread2 (t3);
        Thread1 t1 = new Thread1 (t2);

        t1.start ();
    }
}

class Thread1 extends Thread {
    private Thread nextThread;

    public Thread1 (Thread thread) {
        nextThread = thread;
    }

    public void run () {
        while (condition1) {
              
// CODE THREAD 1


        }
        if (nextThread != null) {
            nextThread.start ();
        }
    }
}

class Thread2 extends Thread {
    private Thread nextThread;

    public Thread2 (Thread thread) {
        nextThread = thread;
    }

    public void run () {
        while (condition2) {
           
// CODE THREAD 2




        }
        nextThread.start ();
    }
}

class Thread3 extends Thread {
    private Thread nextThread;

    public Thread3 (Thread thread) {
        nextThread = thread;
    }

    public void run () {
        while (condition3) {
            // CODE THREAD 3
        }
        nextThread.start ();
    }
}



De cette façcon le thread1 s'exécute lorsque il termine son exécution il donne la main à son successeur qui thread2 et qui à son tour après avoir terminer son exécution cède la main à son successeur qui est thread3.

Si tu utilises un code de ce type:

public static void main (String [] args) {
    // ...
    while (condition-globale) {
        t1.start ();
    }
}

J'espère que ça peut t'aider.


________________________________________________________________________________
A.B. : 
            "Dieu nous donne des mains, mais il ne bâtit pas les ponts

Ombitious_Developper · Answer

Salut:


Si tu utilises un code de ce type, tu obtiendra une exécution circulaire 
t1, t2, t3, t1, t2, t3, ..........:

public static void main (String [] args) {
    // ...
    while (condition-globale) {
        t1.start ();
    }
}




________________________________________________________________________________
A.B. : 
            "Dieu nous donne des mains, mais il ne bâtit pas les ponts

viphadia · Answer

merci de votre attention ta solution est la meillieur jusqu'à maintenent je vais l'essayer ;
j'ai une autre solution c'est de faire une boucle while vide(aucune instruction) et ça résoudre le problème mais pas tellement
public static void main (String [] args) {
    // ...
    while (condition-globale) {
        t1.start ();
        t2.start ();
        t3.start ();
 while (condition(qui est toujours vraie)
{
if((ok1==false)&&(ok2==false)&&(ok3==false))
break;
}
//appel d'autre procédure de calcul...

    }
}

ok1 devient false si l'execution du code de t1  se termine,aussi ok2 par rapport au  t2,et ok3 pour t3.

Ombitious_Developper · Answer

Salut:

J'ai testé ma solution pour afficher le nom du thread et elle marche bien:

Je suis le thread1 ...

Je suis le thread1 ...

Je suis le thread2 ...

Je suis le thread2 ...

Je suis le thread3 ...

Je suis le thread3 ...






exemple:



class Thread3 extends Thread {
    private Thread nextThread;

    public Thread3 (Thread thread) {
        nextThread = thread;
    }

    public void run () {
         int i = 0;
        while (i < 2) {
            System.out.println ("Je suis le thread3 ...");
        }
        if (nextThread != null) {
            nextThread.start ();
        }
    }
}



Refais la même chose avec les méthodes run des thread Thread1 et Thread2.


Je suis le thread1 ...



Je suis le thread2 ...

Dernière remarque:

J'ai oublié d'ajouter le test suivant:



if (nextThread != null) {
    nextThread.start ();
}

Prends le soin d'ajouter ce test à la fin de chaque méthode run, sinon tu va avoir un NullPointerException.

Tiens moi au courant de ce que se passe.

Bonne chance ...



________________________________________________________________________________
A.B. : 
            "Dieu nous donne des mains, mais il ne bâtit pas les ponts"

Ombitious_Developper · Answer

Salut:

Tout le code se trouve dans le fichier EntryPoint.java, testes le:

public class EntryPoint {
    public static void main (String [] args) {
        Thread3 t3 = new Thread3 (null);
        Thread2 t2 = new Thread2 (t3);
        Thread1 t1 = new Thread1 (t2);

        t1.start ();
    }
}

class Thread1 extends Thread {
    private Thread nextThread;

    public Thread1 (Thread thread) {
        nextThread = thread;
    }

    public void run () {
        int i = 0;
        while (i < 10) {
            System.out.println ("This is Thread1");
            ++i;
        }
        if (nextThread != null) {
            nextThread.start ();
        }
    }
}

class Thread2 extends Thread {
    private Thread nextThread;

    public Thread2 (Thread thread) {
        nextThread = thread;
    }

    public void run () {
        int i = 0;
        while (i < 10) {
            System.out.println ("This is Thread2");
            ++i;
        }
        if (nextThread != null) {
            nextThread.start ();
        }
    }
}

class Thread3 extends Thread {
    private Thread nextThread;

    public Thread3 (Thread thread) {
        nextThread = thread;
    }

    public void run () {
        int i = 0;
        while (i < 10) {
            System.out.println ("This is Thread3");
            ++i;
        }
        if (nextThread != null) {
            nextThread.start ();
        }
    }
}


________________________________________________________________________________
A.B. : 
            "Dieu nous donne des mains, mais il ne bâtit pas les ponts"

Ombitious_Developper · Answer

Salut:

Si tu veux poursuivre la trace d'exécution, ajoutes un Thread.sleep ()


________________________________________________________________________________
A.B. : 
            "Dieu nous donne des mains, mais il ne bâtit pas les ponts"

Synchronisation des threads

17 réponses

Votre réponse

Discussions similaires