L'impression de “Bonjour” et “monde” à plusieurs reprises à l'aide de deux threads en java

Ici deux interdépendants fils, nous avons besoin de deux synchronisation d'objets. ils pourraient être l'un des beaucoup de choses. un nombre entier, un autre objet; un Boolean un autre objet; objet; les deux sémaphores et ainsi de suite. la technique de synchronisation peut être soit du Moniteur ou du Sémaphore de la manière que vous voulez, mais ils doivent être deux.

J'ai modifié votre code pour utiliser un sémaphore au lieu de Surveiller. Le Sémaphore de travaux de manière plus transparente. Vous pouvez voir l'acquérir et de la libération qui se passe. Les moniteurs sont même plus des constructions. Donc Synchronisé fonctionne sous le capot.

Si vous êtes à l'aise avec le code suivant, puis vous pouvez le convertir utiliser des Moniteurs de la place.

    import java.util.concurrent.Semaphore;

    public class MainClass {

        static Semaphore hello = new Semaphore(1);
        static Semaphore world = new Semaphore(0);

        public static void main(String[] args) throws InterruptedException {
            MyThread mt=new MyThread();     
            mt.hello = hello;
            mt.world = world;
            mt.start();

            for (int i=0; i<5; i++) {
                hello.acquire(); //wait for it
                System.out.println("Hello");

                world.release(); //go say world
            }
        }
    }

    class MyThread extends Thread{

        Semaphore hello, world;

        public void run(){
            try {
                for(int i = 0; i<5; i++) {
                    world.acquire(); //wait-for it
                    System.out.println("  World!");

                    hello.release(); //go say hello
                }

            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

Avant de commencer à essayer de le faire fonctionner, cinq fois vous avez besoin pour vous assurer qu'il fonctionne une fois!

Votre code n'est pas garanti pour toujours imprimer Bonjour tout le Monde! - le thread principal peut être interrompu avant de prendre le verrou de mt (à noter que le verrouillage sur le thread des objets est généralement pas une bonne idée).

MyThread mt=new MyThread();
mt.start();
\\ interrupted here
synchronized(mt){
  ...

Une approche qui permettra de généraliser à faire à de nombreuses reprises, est d'utiliser un atomique boolean

import java.util.concurrent.atomic.AtomicBoolean;
public class InterThread {

    public static void main(String[] args) {
        int sayThisManyTimes = 5;
        AtomicBoolean saidHello = new AtomicBoolean(false);

        MyThread mt=new MyThread(sayThisManyTimes,saidHello);
        mt.start();

        for(int i=0;i<sayThisManyTimes;i++){
          while(saidHello.get()){} //spin doing nothing!
          System.out.println("Hello ");
          saidHello.set(true);
        }    
    }

}

class MyThread extends Thread{

    private final int sayThisManyTimes;
    private final AtomicBoolean saidHello;
    public MyThread(int say, AtomicBoolean said){
      super("MyThread");
      sayThisManyTimes = say;
      saidHello = said;
    }

    public void run(){
        for(int i=0;i<sayThisManyTimes;i++){
          while(!saidHello.get()){} //spin doing nothing!
          System.out.println("World!");
          saidHello.set(false);
        }
    }
}

Il y a deux fil et deux possède ses propres données ("Bonjour" et fidèle à ht, "le Monde" et la valeur false pour wt), et de partager une variable objturn.

public class HelloWorldBy2Thread {  
public static void main(String[] args) {
PrintHelloWorld hw = new PrintHelloWorld(); 
HelloThread ht = new HelloThread(hw);
WorldThread wt = new WorldThread(hw);
ht.start();
wt.start();
}
}
public class HelloThread extends Thread {   
private PrintHelloWorld phw;
private String hello;
public HelloThread(PrintHelloWorld hw) {
phw = hw;
hello = "Hello";
}   
@Override
public void run(){
for(int i=0;i<10;i++)
phw.print(hello,true);
}
}
public class WorldThread extends Thread {
private PrintHelloWorld phw;
private String world;
public WorldThread(PrintHelloWorld hw) {
phw = hw;
world = "World";
}
@Override
public void run(){
for(int i=0;i<10;i++)
phw.print(world,false);
}
}
public class PrintHelloWorld {  
private boolean objturn=true;
public synchronized void print(String str, boolean thturn){
while(objturn != thturn){
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.print(str+" ");
objturn = ! thturn;
notify();               
}
}