Ein Janken-Spiel für zwei Spieler mit Java, das zwischen Threads konkurriert

【Überblick】

Erstellen Sie 2 Threads, spielen Sie miteinander und zeigen Sie das Ergebnis an. Es wird auf GitHub hochgeladen → 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("Name der ersten Person:" + Thread.currentThread().getName());
			} else {
				System.out.println("Zweitname:" + Thread.currentThread().getName());
			}
		}

		return Janken.getHand();
	}
}

Janken.java

package game;

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

		private final String hand;

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

		public String getHand() {
			return hand;
		}
	}

	/**
	 *Zeigen Sie das Ergebnis von Janken an
	 *
	 * @param firstPlayerHand
	 *Die erste Hand
	 * @param secondPlayerHand
	 *Der Sekundenzeiger
	 */
	public static void getGameResult(Hand firstPlayerHand, Hand secondPlayerHand) {
		//Platzieren Sie vorübergehend den Gewinner von Janken als erste Person
		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("Das ist Aiko.");
		} else if (winner == firstPlayerHand) {
			System.out.println("Die erste Person gewinnt.");
		} else if (winner == secondPlayerHand) {
			System.out.println("Die zweite Person gewinnt.");
		}
		System.out.println("");
	}

	/**
	 *Nimm zufällig Janken's Hand
	 * @gib Jankens Hand zurück
	 */
	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;
	}

	/**
	 *Zeigen Sie die Hand, die der Spieler ausgestreckt hat
	 *
	 * @param firstPlayerHand
	 *Die erste Hand
	 * @param secondPlayerHand
	 *Der Sekundenzeiger
	 * @return So löschen Sie die erste und zweite Hand
	 */
	private static String getPlayerHand(Hand firstPlayerHand, Hand secondPlayerHand) {
		return "Die erste Hand" + String.format("%s", firstPlayerHand.getHand()) + ": Der Sekundenzeiger"
				+ 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 {

	//Anzahl der Thread-Pools für ein Janken-Spiel exklusiv für 2 Spieler"2"Wird begrenzt sein
	private static final int THREAD_POOL_COUNT = 2;
	//Anzahl der Spiele von 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();
			}

			//Zeigen Sie das Ergebnis an, wenn der erste und der zweite Zeiger entschieden sind
			if (count % THREAD_POOL_COUNT == 0) {
				Janken.getGameResult(firstPlayerHand, currentPlayerHand);
			} else {
				firstPlayerHand = currentPlayerHand;
			}
		}
	}
}

[Ausführungsbeispiel]

Vorname: Pool-1-thread-1
Zweiter Name: Pool-1-thread-2
Die erste Hand ist goo: Die zweite Hand ist goo
Das ist Aiko.

Vorname: Pool-1-thread-1
Zweiter Name: Pool-1-thread-2
Die erste Hand ist gut: Die zweite Hand ist par
Die zweite Person gewinnt.

Vorname: Pool-1-thread-2
Zweiter Name: Pool-1-thread-1
Die erste Hand ist par: Die zweite Hand ist gut
Die erste Person gewinnt.

【Referenz】

Multithread-Verarbeitung in Java mit ExecutorService Wenn sich das im synchronisierten Block verwendete StaticObject ändert, wird es nicht effektiv synchronisiert

[Probleme / Verbesserungen]

・ Du kannst das Janken-Spiel nicht mit mehr als 3 Personen (3 Threads) spielen. -Ich wollte die Position des resultierenden Doppelpunkts ausrichten (:).

[Bonus Ecke]

Die Thread-Verarbeitung ist schwierig.