Problèmes avec les threads

Question

Je suis plus récent avec des discussions et je dois corriger cette erreur pourriez-vous m'aider?

Désolé était ma faute c'est ce que je dois faire:

Cette application Web doit exécuter 1000 jeux et afficher les résultats de sortie.

Mes excuses à nouveau.

Merci

/** 
* 
* Automatic agent to play 1000 games 
* 
*/ 
public class AutoPlayer implements Runnable { 

    private RequestDispatcher requestDispatcher; 

    public AutoPlayer(RequestDispatcher requestDispatcher) { 
    this.requestDispatcher = requestDispatcher; 
    } 


    public static void main(String[] args) { 

    HashMap<String, Game> games = new HashMap<String, Game>(); 

    RequestDispatcher rd = new RequestDispatcher(games); 

    Vector<Thread> threads = new Vector<Thread>(); 

    for (int i = 0; i < 10; i++) { 
     AutoPlayer autoPlayer = new AutoPlayer(rd); 
     Thread thread = new Thread(autoPlayer); 
     threads.add(thread); 
     thread.start(); 
    } 

    for (int i = 0; i < threads.size(); i++) { 
     try { 
     threads.get(i).join(); 
     } catch (InterruptedException e) { 
     e.printStackTrace(); 
     } 
    } 

    } 



    @Override 
    public void run() { 

    PlayResponse response = null; 

    for (int i = 0; i < 1000; i++) { 
     byte[] numbers = requestDispatcher.cardRequest(); 

     try { 
     response = new PlayResponse(); 
     requestDispatcher.process("Lucky", 10, numbers, response); 
     } catch (UnknownGameException e) { 
     e.printStackTrace(); 
     } 

     if (response != null) { 
     System.out.println("[" + Thread.currentThread() + "] total requests:" + requestDispatcher.generatedCards); 
     } 
    } 
    } 

} 



public class Game { 

    private String name; 
    private int gamesPlayed; 

    public String getName() { 
    return name; 
    } 

    public void setName(String name) { 
    this.name = name; 
    } 

    public int getGamesPlayed() { 
    return gamesPlayed; 
    } 

    public void setGamesPlayed(int gamesPlayed) { 
    this.gamesPlayed = gamesPlayed; 
    } 

} 



/** 
* 
* Response to a Play request 
* 
*/ 
public class PlayResponse { 

    private boolean error; 
    private long win; 

    public boolean isError() { 
     return error; 
    } 
    public void setError(boolean error) { 
     this.error = error; 
    } 
    public long getWin() { 
     return win; 
    } 
    public void setWin(long win) { 
     this.win = win; 
    } 

} 




/** 
* 
* Object that processes play requests, calculates outcomes and returns results. 
* 
*/ 
public class RequestDispatcher { 

    List<String> list = Arrays.asList("Lucky", "Happy", "Extra"); 

    final int CARD_SIZE = 15; 

    public String GAME_UNAVAILABLE = "Error: Game not available"; 

    Map<String, Game> games; 

    long generatedCards; 

    Logger logger = Logger.getLogger(getClass().getName()); 

    Random r = new Random(); 

    public RequestDispatcher(HashMap<String, Game> games) { 
    this.games = games; 

    } 

    public byte[] cardRequest() { 
    byte[] result = createCard(); 
    generatedCards++; 

    return result; 
    } 

    private byte[] createCard() { 

    byte[] result = new byte[CARD_SIZE]; 

    r.nextBytes(result); 

    return result; 
    } 

    public void process(String s, int i, byte[] bb, PlayResponse pr0) throws UnknownGameException { 

    if (!list.contains(s)) { 
     logger.log(Level.SEVERE, GAME_UNAVAILABLE); 
     throw new UnknownGameException(GAME_UNAVAILABLE); 
    } 

    Game game = games.get(s); 

    if (game != null) { 
     game.setGamesPlayed(game.getGamesPlayed() + 1); 
    } else { 
     Game g = new Game(); 
     g.setName(s); 
     games.put(s, g); 
     g.setGamesPlayed(0); 
    } 

    pr0.setWin(r.nextInt(3) * i); 
    pr0.setError(false); 

    } 
} 


public class UnknownGameException extends Exception { 

    private static final long serialVersionUID = 2380720995275983122L; 

    public UnknownGameException(String s) { 
    super(s); 
    } 
} 

Answer 1

Le code crée 10 threads dans main. Chaque thread joue 1000 parties en run. Cela donne un total de 10 * 1000 = 10000 jeux.

Pour changer le nombre de jeux, changez simplement ces chiffres.

Answer 2

Si vous devez exécuter run 1000 fois en utilisant 10 threads, tenez compte des options suivantes.

1. Faites que chaque thread s'exécute 100 fois.
2. Utilisez un compteur statique qui est partagé entre les threads un arrêt s'exécutant lorsque le compteur atteint 1000. Assurez-vous d'utiliser un AtomicInteger pour le compteur afin de s'assurer qu'il est thread-safe.

Answer 3

Dans le code, vous créez 10 threads dans main. Modifiez simplement le nombre de threads et utilisez la synchronisation pour les champs et les méthodes partagés.