Comment puis-je faire simultanément threads en cours d'exécution?

Je veux avoir deux threads s'exécutant deux différentes instances de classes différentes et je les veux pour exécuter la commande exécuter en même temps.

J'ai fait une pratique de classe pour illustrer le problème que je vais avoir.
Un coureur de compte vers l'avant, les autres chefs d'accusation à l'envers.

public class testCount {

    public static void main(String args[]) {
        testCount countCompetition = new testCount();
        countCompetition.run();
    }

    public void run() {
        (new Thread(new racer1())).start();
        (new Thread(new racer2())).start();
    }

    public class racer1 implements Runnable {
        public void run() {
            for(int x = 0; x < 100; x++) {
                System.out.println(x);
            }
        }
    }
    public class racer2 implements Runnable {
        public void run() {
            for(int y = 100; y > 0; y--) {
                System.out.println(y);
            }
        }
    }
}

Mes résultats

1
2
... All the way to 100
100
100
99
... All the way back down
1

Ce que je veux

Ils n'ont pas besoin d'être comme ça, mais ils n'ont besoin de travailler en même temps, au lieu de les uns après les autres.
Tous les conseils, des conseils ou des extraits de code serait grandement apprécié.

OriginalL'auteur James | 2013-04-19

1

Juste ajouter Thread.sleep(1); dans chaque racer classe après System.out.println().

c'est à dire, il ressemblera à ceci:
```
public class racer1 implements Runnable {
    public void run() {
        for(int x = 0; x < 100; x++) {
            System.out.println(x);
            try {
                Thread.sleep(1);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }
    }
}
```
Super, ça fonctionne. Je ne pense pas qu'il serait si simple.
le problème de ne pas avoir à attendre/le sommeil, c'est que le premier thread sera occupé à 100 % du temps, de sorte que le deuxième thread n'obtiendrez pas alloué de temps CPU.
il ne sera également pas garantir que les threads d'exécuter l'une après l'autre. Vous devez attendre et informer les uns les autres quand ils ont fini la tâche
Merci pour les conseils. Heureusement, le fils alternant n'est pas indispensable pour cette partie de mon projet. Je vais le garder à l'esprit dans l'avenir.
n'a jamais jamais être une façon d'éviter condition de course, et pire, il consomme plus de CPU pour..rien si elle se réveille et que la condition (autre thread de travail) n'est pas encore fait. Dans votre cas, il est tout à fait possible de générer des résultats inattendus (cause non ordonnée). Un de la meilleure façon de gérer votre cas: docs.oracle.com/javase/1.5.0/docs/api/java/util/concurrent/... (mieux que les traditionnels de base wait/notify)

OriginalL'auteur Andremoniy
7

Je pense que toutes les réponses sont à côté de la question.

Votre logique ne permettre à vos deux threads s'exécutent simultanément, mais ce n'est pas évident parce que vos numéros seulement aller jusqu'à 100, et l'exécution sera généralement rester avec un thread spécifique pour plus de 1 instruction à la fois, sinon, il y aurait une grande quantité de surcharge lors de la commutation entre le thread en cours d'exécution tout le temps. Dans votre cas, la JVM est de décider de l'exécution de votre premier fil assez long pour elle, pour imprimer les 100 numéros avant de "changement de contexte" pour le 2ème fil. La JVM peut choisir d'exécuter les threads différemment, de sorte que le résultat que vous voyez n'est pas garanti d'être le même à chaque fois.

Si vous augmentez le même nombre de 1000 (probablement) voir les deux fils de l'entrelacement quelque peu. Vous aurez toujours de grandes courses où un thread imprime beaucoup de nombres dans une ligne, car il est plus efficace pour la JVM pour exécuter un thread pour un certain temps avant de passer, au lieu de la commutation de contexte entre chaque instruction.

L'Ajout De Fil.sleep(1) n'est pas une bonne solution, comme l'ajout d'un retard inutile. Bien sûr, pour 100 chiffres, cela pourrait ne pas être sensible mais pour 10000 numéros vous disposez d'un délai de 10 secondes.

Est-il une raison qui vous oblige à interleave à un degré plus élevé que ce qu'ils font déjà? Si il y est, alors votre modèle simple d'exécuter deux threads simultanément n'est pas suffisant. Si non, alors laissez juste le JVM décider de la meilleure pour faire fonctionner votre fils (qui dans l'exemple que vous avez donné, signifie qu'ils ne sera probablement pas interleave la plupart du temps).

Je n'ai aucune idée de pourquoi vous avez été downvoted pour cette analyse. Corriger avec un upvote.

OriginalL'auteur Joe Elleson

-1

Vous avez besoin d'écrire une base d'attendre et d'en aviser le système. Une tâche doit notifier à l'autre qu'il a pêché le travail. L'idée de base peut être dérivée à partir de code ci-dessous. créer 2 tâches, l'une à compter de l'avant et un à compte à rebours

Runnable task = new Runnable() {
  public void run() {
    System.out.println("woohooTwo");
    synchronized (t) {
      while (true) {
        System.out.println("---" + Thread.currentThread().getName() + "--" + t.i.getAndIncrement());
        t.notifyAll();

        try {
          Thread.sleep(1000);
          t.wait();
        } catch (InterruptedException e) {
          //TODO Auto-generated catch block
          e.printStackTrace();
        }
      }

    }
  }
};

quelqu'un peut-il gagner un peu de temps pour expliquer la baisse de vote.

OriginalL'auteur Edge

Vous devez vous connecter pour publier un commentaire.