暂停java中的线程

我想知道是否有人能帮我实现一个线程，该线程在后台无限运行，直到用户按p时它暂停其他线程，按r时恢复其他线程。这是一些代码

一些主要对象

public class CardGame
{
   static Player[] players;
   static int handSize;
   static Queue<Card>[] playingDeckArray;


public static void main(String[] args){
        Scanner reader = new Scanner(System.in);

        System.out.println( "\nHello, how many players would you like" );
        int playersNum = Integer.parseInt(Checks.userInputCheck( "\\d" ));
        System.out.println( "\nHow many cards should each player begin with" );
        int handSize = Integer.parseInt(Checks.userInputCheck( "\\d" ));
        System.out.println( "\nWhich strategy would you like to use 1 or 2" );
        int strategy = Integer.parseInt(Checks.userInputCheck( "[12]$" ));

        Logger.createDeck( playersNum, handSize );

        makePlayers( playersNum, handSize, strategy );

        makePlayingDecks( playersNum );

        dealInitialHand( playersNum, players, handSize );

        makePlayerOutputs();

        for ( int i = 0; i < players.length; i++){
           logInitialHand(players[i]);
        }

        CardGame cG = new CardGame();
        cG.startPauseThread();

        for ( int i = 0; i < players.length; i++){
            new Thread(players[i]).start();
        }
   }

   public void startPauseThread(){
   Thread add = new Thread( pauseInputThread );
   add.start();
}


Thread pauseInputThread = new Thread(){
       public void run(){ 
         int i = 0;
         for(;;){
             System.out.println("i'm still here" );
             Scanner reader = new Scanner(System.in);
             String result = Checks.userInputCheck( "[pPrR]$" );
             i++;
             System.out.println(i);
            }
       }
};
}

公共类卡片游戏
{
静态玩家[]玩家；
静态int-handSize；
静态队列[]播放deckarray；
公共静态void main（字符串[]args）{
扫描仪阅读器=新扫描仪（System.in）；
System.out.println（“\nHello，您想要多少玩家”）；
int playersNum=Integer.parseInt（Checks.userInputCheck（“\\d”）；
System.out.println（“\n每个玩家应该以多少张牌开始”）；
int handSize=Integer.parseInt（Checks.userInputCheck（“\\d”）；
System.out.println（“\n您希望使用哪种策略1或2”）；
int strategy=Integer.parseInt（Checks.userInputCheck（“[12]$”）；
Logger.createDeck（playersNum，handSize）；
makePlayers（playersNum、handSize、strategy）；
制作游戏甲板（playersNum）；
dealInitialHand（playerNum、players、handSize）；
makePlayerOutputs（）；
for（int i=0；i

要暂停的线程的播放器对象

public class Player implements Runnable
{
    Card[] hand;
    String playerName;
    int strategyChosen;

    public void run(){
        System.out.println( "les do dis" );
    }

    private Player(){
    }

    public Player( int strategy, int cardsInHand, int playerNumber ){
        hand = new Card[cardsInHand];
        strategyChosen = strategy;
        playerName = "Player " + playerNumber;
    }

    public String getPlayerName(){
        return playerName;
    }

    public void fillHand(){
       for ( int i = 0; i < hand.length; i++){
            hand[i] = new Card(0);
       }
    }

    public void setHand( int value, int index ){
        hand[index].setCardValue( value );
    }

    public void seeHand(){
        for ( int i = 0; i < hand.length; i++){
            System.out.println( hand[i].getCardValue() );
        }
    }

    public String getHand(){
        String result = "";
        for ( int i = 0; i < hand.length; i++ ){
            result = result +  hand[i].getCardValue() + " \n" ;
        } 
        return result;
    }

    public int getHandValue( Card card ){
        return card.getCardValue();
    }

公共类播放器实现可运行
{
卡片[]手；
弦乐演奏者姓名；
国际战略选择；
公开募捐{
System.out.println（“les do dis”）；
}
私人玩家（）{
}
公共玩家（int策略、int牌单手、int玩家编号）{
手牌=新卡[卡片手牌]；
战略选择=战略；
playerName=“Player”+玩家编号；
}
公共字符串getPlayerName（）{
返回playerName；
}
公营机构{
对于（int i=0；i

}

玩家将“玩游戏”，从阵列中绘制和丢弃对象，但用户应该能够在游戏期间的任何时间暂停并恢复程序。我只是不太明白如何使用事件和列表器

---

我们将不胜感激。谢谢。

不可能通过调用预定义的方法来暂停线程，也不可能终止线程。你唯一能做的就是自己实现这个行为。这意味着您将执行以下操作：

public class MyThread extends Thread {
    private volatile boolean running = true;
    private volatile boolean paused  = false;

    public void kill() {
        this.running = false;
    }

    public void setPaused(boolean paused) {
        this.paused = paused;
    }

    @Override
    public void run() {
        while (running) {
            if (!paused) {
                // do another step
            }
        }
    }
}

---

然而，我可能没有正确理解你的问题。请给我一个反馈，这样我最终可以更新我的答案。

线程本身并没有实现这一点的机制。但是，您可以轻松地将此功能添加到自己的流程中。您将需要设置和检查一些标志，然后最好是使用等待/通知方案。下面是一个简单的演示：

abstract class PausableTask implements Runnable {
    private volatile boolean paused;
    private final Object lock = new Object();

    void setPaused(boolean shouldPause) {
        synchronized (lock) {
            paused = shouldPause;
            if (!paused) {
                lock.notify();
            }
        }
    }

    boolean isPaused() { return paused; }

    @Override
    public void run() {

        for (;;) {                
            synchronized (lock) {
                while (paused) {
                    try {
                        lock.wait();
                    } catch (InterruptedException e) {}
                }
            }

            doTask();
        }
    }

    abstract void doTask();
}

class Counter {
    volatile long count;

    public static void main(String[] args) {
        final Counter counter = new Counter();

        PausableTask increment = new PausableTask() {
            @Override
            void doTask() {
                counter.count++;
            }
        };

        PausableTask decrement = new PausableTask() {
            @Override
            void doTask() {
                counter.count--;
            }
        };

        decrement.setPaused(true);
        PausableTask next = increment;

        Scanner in = new Scanner(System.in);
        long count = counter.count;

        new Thread(increment).start();
        new Thread(decrement).start();

        for (;;) {
            System.out.print(
                (next == increment ? "Counting up from " : "Counting down from ")
                + count + ". Enter 'exit' to abort or anything else to toggle: "
            );

            if (in.nextLine().equals("exit")) {
                System.exit(0);
            }

            if (increment.isPaused()) {
                next = increment;
                decrement.setPaused(true);
            } else {
                next = decrement;
                increment.setPaused(true);
            }

            count = counter.count;
            next.setPaused(false);
        }
    }
}

对于从键盘获取用户输入，在Java中并没有真正方便的方法。如果你想直接击键，你需要一个GUI组件来实现。如果您确实计划实现GUI，请查看。
是什么行动使游戏前进了一步？只要不这样做，游戏就会“暂停”。旁注：为什么你需要线程呢？你的玩家不是并行玩的，他们的动作是按顺序进行的。玩家线程除了打印一条太阳光线之外什么都不做。没有什么需要暂停的。但要回答你的问题：线程不能从外部暂停。抱歉，我还没有完全弄清楚游戏的步骤，但是玩家线程将独立进行并向数组中添加项目，直到有人获胜，我只是想知道，如果用户输入，我如何暂停/使线程休眠，以及如何进行。不，这很有用，我只是不确定如何让后台运行的线程等待用户暂停，以及如何将暂停通知其他线程，但这很有用。谢谢你，那样不行。布尔变量必须是volatile或AtomicBoolean类型才能正常工作。它还将使线程进入一个繁忙的循环，在暂停时消耗所有的CPU，而不是在唤醒前一直处于空闲状态。因此，答案是正确的，但示例代码不是。我无法解释的主要部分是如何在用户输入上创建线程，我是否需要创建一个keylisterner方法，以某种方式通知其他线程暂停。KeyLister用于AWT/Swing应用程序，而不是基于控制台的应用程序。哦，那么我该如何实现呢？我的代码有一个线程，它应该在后台无限地运行，等待用户响应，但在我运行程序时却没有