Un jeu Janken à deux joueurs avec Java où les threads se jouent les uns contre les autres

【Aperçu】

Créez 2 fils, jouez les uns avec les autres et affichez le résultat. Il est téléchargé sur GitHub → threadJankenGame

【code】

JankenCallable.java

package game;

import java.util.concurrent.Callable;
import java.util.concurrent.TimeUnit;

import game.Janken.Hand;

public class JankenCallable implements Callable<Janken.Hand> {

	public static int playerNumber = 1;
	public final static Object lock = new Object();

	@Override
	public Hand call() throws Exception {
		TimeUnit.SECONDS.sleep(1);

		synchronized (lock) {
			playerNumber++;

			if (playerNumber % 2 == 0) {
				System.out.println("Nom de la première personne:" + Thread.currentThread().getName());
			} else {
				System.out.println("Nom de famille:" + Thread.currentThread().getName());
			}
		}

		return Janken.getHand();
	}
}

Janken.java

package game;

public class Janken {
	public enum Hand {
		GUU("Goo"), CHOKI("Choki"), PAA("Par");

		private final String hand;

		private Hand(String hand) {
			this.hand = hand;
		}

		public String getHand() {
			return hand;
		}
	}

	/**
	 *Afficher le résultat de Janken
	 *
	 * @param firstPlayerHand
	 *La première main
	 * @param secondPlayerHand
	 *La seconde main
	 */
	public static void getGameResult(Hand firstPlayerHand, Hand secondPlayerHand) {
		//Placez temporairement le gagnant de Janken comme première personne
		Hand winner = firstPlayerHand;

		if (firstPlayerHand == Hand.GUU && secondPlayerHand == Hand.PAA) {
			winner = secondPlayerHand;
		} else if (firstPlayerHand == Hand.CHOKI && secondPlayerHand == Hand.GUU) {
			winner = secondPlayerHand;
		} else if (firstPlayerHand == Hand.PAA && secondPlayerHand == Hand.CHOKI) {
			winner = secondPlayerHand;
		}

		System.out.println(getPlayerHand(firstPlayerHand, secondPlayerHand));
		if (firstPlayerHand == secondPlayerHand) {
			System.out.println("C'est Aiko.");
		} else if (winner == firstPlayerHand) {
			System.out.println("La première personne gagne.");
		} else if (winner == secondPlayerHand) {
			System.out.println("La deuxième personne gagne.");
		}
		System.out.println("");
	}

	/**
	 *Prenez la main de Janken au hasard
	 * @retourner la main de Janken
	 */
	public static Hand getHand() {
		double random = Math.random() * 10;
		if (6.6 < random) {
			return Hand.GUU;
		} else if (3.3 < random) {
			return Hand.CHOKI;
		}
		return Hand.PAA;
	}

	/**
	 *Montrez la main que le joueur a lancée
	 *
	 * @param firstPlayerHand
	 *La première main
	 * @param secondPlayerHand
	 *La seconde main
	 * @retour Comment sortir la première et la seconde main
	 */
	private static String getPlayerHand(Hand firstPlayerHand, Hand secondPlayerHand) {
		return "La première main" + String.format("%s", firstPlayerHand.getHand()) + ": La seconde main"
				+ String.format("%s", secondPlayerHand.getHand());
	}

}

Main.java

package game;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

import game.Janken.Hand;

public class Main {

	//Nombre de pools de threads pour un jeu Janken exclusivement pour 2 joueurs"2"Sera limité
	private static final int THREAD_POOL_COUNT = 2;
	//Nombre de parties de Janken
	private static final int GAME_COUNT = 3;

	public static void main(String[] args) {
		ExecutorService executorService = Executors.newScheduledThreadPool(THREAD_POOL_COUNT);

		List<Future<Hand>> jankenList = new ArrayList<>();
		for (int i = 0; i < GAME_COUNT * 2; i++) {
			Future<Hand> future = executorService.submit(new JankenCallable());
			jankenList.add(future);
		}

		int count = 0;
		Hand firstPlayerHand = null;
		Hand currentPlayerHand = null;
		for (Future<Hand> hand : jankenList) {
			count++;

			try {
				currentPlayerHand = hand.get();
			} catch (InterruptedException e) {
				e.printStackTrace();
			} catch (ExecutionException e) {
				e.printStackTrace();
			} finally {
				executorService.shutdown();
			}

			//Afficher le résultat lorsque la première et la deuxième mains sont décidées
			if (count % THREAD_POOL_COUNT == 0) {
				Janken.getGameResult(firstPlayerHand, currentPlayerHand);
			} else {
				firstPlayerHand = currentPlayerHand;
			}
		}
	}
}

[Exemple d'exécution]

Prénom: piscine-1-thread-1
Deuxième nom: piscine-1-thread-2
La première main est goo: la seconde main est goo
C'est Aiko.

Prénom: piscine-1-thread-1
Deuxième nom: piscine-1-thread-2
La première main est goo: la seconde main est par
La deuxième personne gagne.

Prénom: piscine-1-thread-2
Deuxième nom: piscine-1-thread-1
La première main est normale: la seconde main est gluante
La première personne gagne.

【référence】

Traitement multi-thread en Java à l'aide d'ExecutorService Si le StaticObject utilisé pour le bloc synchronisé change, il n'est pas effectivement synchronisé

[Problèmes / améliorations]

・ Vous ne pouvez pas jouer au jeu Janken avec plus de 3 personnes (3 fils). -Je voulais aligner la position des deux points résultants (:).

[Coin bonus]

Le traitement du fil est difficile.