Scanner.nextInt（）阻止

Question

My code is working fine if it is the following way.

Scanner input = new Scanner(System.in);
ExecutorService executor = Executors.newFixedThreadPool(2);
for (int i = 0; i < 3; i++) 
{
     Runnable worker = new ClassA();
     executor.execute(worker);
} 

Instead, I want to run continuously in while(true) loop and break the loop when user enters 1. I tried the following way but it is not working. it is not running continously but stopping (blocking) at this line int stop = input.nextInt(); Can anyone please tell me where the mistake is. Whether it is the correct way of doing or not if not please suggest an alternative. My code in Class A connects to jms queue and should continuously read messages from queue.

Scanner input = new Scanner(System.in);
ExecutorService executor = Executors.newFixedThreadPool(2);
while(true)
{
     Runnable worker = new ClassA();
     executor.execute(worker);
     int stop = input.nextInt();
     if(stop == 1) {
            break;
     }
 }

EDIT : The following is the edited code. when scanner.nextInt() value is entered 1, finished = true. While(!finished) loop is break, code in it is not executing but still my Consumer class is running continuously.

public class ScannerProblem {
   public static boolean finished = false;
   static class Listener implements Runnable {
      Scanner scanner = new Scanner(System.in);
      @Override
        public void run() {
            while (true) {
                System.out.println("scanning");
                if (scanner.nextInt() == 1) {
                    System.out.println("scanning finished");
                    finished = true;
                    return;
                } else {
                    System.out.println("scanned something strange");
                    try {
                        Thread.sleep(1500);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }

    static class Consumer implements Runnable {
        javax.jms.Connection jmsConnection = null;
        private static ProcessRequest processRequest = new ProcessRequest();
        @Override
        public void run() {
            ActiveMQConnection con = new ActiveMQConnection();
            jmsConnection = con.openTcpConnection();
            try {
                String json = null;
                Session session = jmsConnection.createSession(false,
                        Session.AUTO_ACKNOWLEDGE);
                Queue queue = session.createQueue("Upload_Queue");
                MessageConsumer consumer = session.createConsumer(queue);
                TextMessage message = (TextMessage) consumer.receive();
                System.out.println("Message #" + ": " + message.getText());
                json = message.getText();
                processRequest.upload(json);
                System.out.println("Thread ID: " +                 Thread.currentThread().getId());

            if (jmsConnection != null) {

                    jmsConnection.close();
            }

            Thread.sleep(5000);
        }
            catch(JMSException e) {
                e.printStackTrace();
            }
            catch(InterruptedException e){
                e.printStackTrace();
            }
            catch(Exception e) {
                e.printStackTrace();
            }
            }
    }



    public static void main(String[] args) {
        ExecutorService pool = Executors.newFixedThreadPool(2);
        pool.submit(new Listener());

        while (!finished) {
            System.out.println("finished::"+finished);
            pool.submit(new Consumer());
            try {
                Thread.sleep(4000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

Answer 1

int stop = input.nextInt() is a blocking call, so it execute ClassA runnable only once then wait for input.

You need to move input code to another thread so it's not blocking the executions of ClassA.

Maybe a better option would be to have only one execution of ClassA and have another while(true) loop inside it.