java如何实现一个线程增序打印数字，另一个线程在控制台接收用户指令？

Question

java实现一个线程A增序打印数字，另一个线程B在控制台接收用户指令
比如用户输入c,则线程A改为减序打印数字，如果用户不输入则一直打印

坐等大佬

Answer 1

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Queue;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * Created with IntelliJ IDEA.
 * Description:
 * Date: 2017-10-30
 * Time: 15:33
 */
public class test {
    enum Command{
        ADD,SUBTRACT
    }
    private static AtomicInteger val = new AtomicInteger(0);

    private static volatile Command state = Command.ADD;

    static Queue<Command> commandQueue = new ArrayBlockingQueue<Command>(1);

    static Thread commandThread = new Thread(new Runnable() {
        @Override
        public void run() {
            BufferedReader br = null;

            try {
                br = new BufferedReader(new InputStreamReader(System.in));

                while (true) {

                    System.out.print("Enter something : ");
                    String input = br.readLine();
                    switch (input){
                        case "add":
                            commandQueue.add(Command.ADD);
                            break;
                        case "subtract":
                            commandQueue.add(Command.SUBTRACT);
                    }
                    System.out.println("input : " + input);
                    System.out.println("-----------\n");
                }

            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                if (br != null) {
                    try {
                        br.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }

        }
    });

    static Thread outputThread = new Thread(new Runnable() {
        @Override
        public void run() {
            while(true) {
                if (!commandQueue.isEmpty()) {
                    state = commandQueue.poll();
                }
                switch (state) {
                    case ADD:
                        System.out.println(val.addAndGet(1));
                        break;
                    case SUBTRACT:
                        System.out.println(val.addAndGet(-1));
                        break;
                }
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

        }
    });

    public static void main(String[] args) {
        commandThread.start();
        outputThread.start();
    }
}

Answer 2

import java.util.Scanner;
import java.util.concurrent.atomic.AtomicInteger;

public class Test {
    
    public static AtomicInteger number = new AtomicInteger(0);
    
    private static volatile boolean isAsc = true;
    
    
    public static void main(String[] args) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                while(true){
                    try {
                        Thread.sleep(2000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    if(isAsc){
                        System.out.println(number.incrementAndGet());
                    }else{
                        System.out.println(number.decrementAndGet());
                    }
                }
            }
        }).start();
        
        new Thread(new Runnable() {
            @Override
            public void run() {
                Scanner s = new Scanner(System.in);
                while(true){
                    String str = s.nextLine();
                    if("c".equals(str)){
                        isAsc = !isAsc;
                    }
                }
            }
        }).start();
        
        
    }
}