Exemple d'interface exécutable

public class CreateThreadRunnableExample implements Runnable {

    public void run() {

        for (int i = 0; i < 5; i++) {
            System.out.println("Child Thread : " + i);

            try {
                Thread.sleep(50);
            } catch (InterruptedException ie) {
                System.out.println("Child thread interrupted! " + ie);
            }
        }

        System.out.println("Child thread finished!");
    }

    public static void main(String[] args) {

        Thread t = new Thread(new CreateThreadRunnableExample(), "My Thread");

        t.start();

        for (int i = 0; i < 5; i++) {

            System.out.println("Main thread : " + i);

            try {
                Thread.sleep(100);
            } catch (InterruptedException ie) {
                System.out.println("Child thread interrupted! " + ie);
            }
        }
        System.out.println("Main thread finished!");
    }
}

dans ce programme, deux de sommeil méthodes sont utilisées de deifferent temps..,,, donc si thread principal de l'exécution enfants thread avez à courir 2 fois.mais il s'exécute qu'une seule fois....elle nous prenons le concept de l'exécutable ou de l'état d'exécution....ensuite, lorsque le thread principal de la fin,alors 2 threads enfants seront dans l'état prêt, alors pourquoi un seul enfant thread s'exécute.

source d'informationauteur bimal chawla

  1. 2

    La sleep méthode n'est pas à 100% précision en temps, comme indiqué dans le JavaDoc:

    public static void sleep(long millis)
    throws InterruptedException

    Provoque le thread en cours d'exécution pour le sommeil (de cesser temporairement l'exécution) pour la
    nombre de millisecondes spécifié, sous réserve de la précision et de l'
    la précision du système des minuteries et des planificateurs. Le thread ne pas perdre
    la propriété de tous les moniteurs.

    Donc, fondamentalement, le code peut parfois fonctionner comme prévu et les autres fois pas.

    Aussi, vous semblez être à partir de seulement 1 enfant, alors, pourquoi vous attendez-vous 2?

    EDIT: En théorie oui, l'enfant thread doit exécuter deux fois pendant la main thread est endormi. Cela étant dit, comme expliqué dans la JavaDoc, la précision avec laquelle la sleep méthode exécute dépend du système sur lequel il est en cours d'exécution, à la fois, vous pourriez le faire fonctionner comme prévu et d'autres fois non. Ainsi, par exemple, vous pourriez avoir des scénarios où la main fil dort pour, dire, par exemple, 97 millisecondes et non pas 100, tandis que l'enfant, dort pour, disons, 53 millisecondes. Ce sera la cause de l'enfant à exécuter qu'une seule fois.

    Une autre option serait de faire quelque chose comme ça:
    while (currentTime <= timeNeededToElapse) { currentTime=... }. Cela provoque une boucle étroite alors ce qui pourrait offrir un meilleur contrôle, mais il est encore, à ma connaissance, pas précis à 100% pour ne pas mentionner que vous serez consommation de cycles de PROCESSEUR pour ne rien faire, c'est donc être utilisées avec prudence.

  2. 3

    Tout d'abord, vous avez ajouté au Système..println("Enfant thread interrompu! "+ ie); pour à la fois le principal et l'enfant thread, c'est une faute de frappe...

    Essayer ce... à la Fois que les fils sont en cours d'exécution (Principal et l'Enfant thread)

    Méthode principale de ce programme est de mettre sur le bas de le thread Principal créé par la JVM, et
    la Principale méthode crée une autre Exécution de la Pile et met l'enfant thread.

    public class DemoThread implements Runnable {

    public void run() {

        for (int i = 0; i < 3; i++) {
            System.out.println("Child Thread ");

            try {
                Thread.sleep(200);
            } catch (InterruptedException ie) {
                System.out.println("Child thread interrupted! " + ie);
            }
        }

        System.out.println("Child thread finished!");
    }

    public static void main(String[] args) {

        Thread t = new Thread(new DemoThread ());

        t.start();

        for (int i = 0; i < 3; i++) {

            System.out.println("Main thread);

            try {
                Thread.sleep(200);
            } catch (InterruptedException ie) {
                System.out.println("Child thread interrupted! " + ie);
            }
        }
        System.out.println("Main thread finished!");
    }
}
  3. 1

    Vous démarrez un seul enfant thread alors, pourquoi vous attendez-vous deux?

    Sur les délais d'attente, le temps de sommeil n'est pas exacte, si bien que l'un thread dort pendant 100 ms, un autre peut ou ne peut pas dormir à deux reprises pour 50 ms. C'est un exemple classique d'un "race condition" . Si vous exécutez l'exemple de code plusieurs fois, vous pouvez voir les deux enfants sont des messages de thread dans certains cas, et un dans les autres cas.

  4. 0

    ESSAYER CETTE 

      public class Test implements Runnable{

        public void run() {

            for (int i = 0; i < 5; i++) {
                System.out.println("CHILD THREAD : " + i);

                try {
                    Thread.sleep(50);
                } catch (InterruptedException ie) {
                    System.out.println("CHILD THREAD INTERRUPTED! " + ie);
                }
            }

            System.out.println("CHILD THREAD FINISHED!");
        }

        public static void main(String[] args) {

            Thread t = new Thread(new Test());

            t.start();

            for (int i = 0; i < 5; i++) {
                System.out.println("MAIN THREAD : " + i);
                try {
                    Thread.sleep(200);
                } catch (InterruptedException ie) {
                    System.out.println("CHILD THREAD INTERRUPTED! " + ie);
                }
            }
            System.out.println("MAIN THREAD FINISHED!");
        }
    }