在Java中使用线程组合计数器和用户输入？

我是一名学生，最近在学习线程。我想做的是实现MVC模式，管理诸如开始计数、停止计数、反向计数等功能

我的最终目标是，当计数器从1开始计数时，我需要获得用户输入，如果我输入2（假设选项2停止计数器），计数器应该停止计数

例如：

Counting...
1
2
3
(If I press 2 here)
Counter stopped running!

因为这是我大学的作业，所以我不能把我实现的代码上传到这里

我所做的是

MVC模式：

控制器类=使用控制器构造函数获取模型和视图。此类还提供了service（）方法，该方法使用switch case让用户输入以选择用于运行计数功能的选项（例如case1:startCounting（）case2:stopCounting（）等等）

View class=使用System.out.println和displayMenu（）函数提供选项

Model class=实现诸如startCounting（）、stopCounting等功能

我现在需要为这个实现添加线程，以便与这个计数过程交互用户输入

我能得到一些提示吗？例如，我应该扩展线程的哪个类，我应该以什么方式实现run（）方法

骨架代码：

CountController类

public class CounterController {
    private Counter model;
    private CounterView view;

    public CounterController(Counter model, CounterView view) {
        this.model = model;
        this.view = view;
    }
}

public class Counter {
    private int count = 0;
    private boolean counting = false;
    private Integer ceiling = null;
    private Integer floor = null;
    private boolean reverse = false;

    public void startCounting() {
        counting = true;
        while (counting && checkLimits()) {
            try {
                Thread.sleep(1000);
                count = reverse ? count - 1 : count + 1;

                // You should replace this print with something observable so the View can handle it
                System.err.println(count);
            } catch (InterruptedException ignored) {}
        }
    }

    public void stopCounting() {
        counting = false;
    }

    public void setReverse(boolean reverse) {
        this.reverse = reverse;
    }

    public void setCeiling(Integer ceiling) {
        this.ceiling = ceiling;
    }

    public void setFloor(Integer floor) {
        this.floor = floor;
    }

    public int getCount() {
        return count;
    }

    public void resetCount() {
        count = 0;
    }

    private boolean checkLimits() {
        if (null != ceiling && count >= ceiling) {
            return false;
        }
        if (null != floor && count <= floor) {
            return false;
        }

        return true;
    }
}

public class CounterView {
    private Counter model;

    public CounterView(Counter model) {

        this.model = model;
    }

    public void launch() {

    }
}

    class ViewUtils {
    static int displayMenu(String header, String[] options, String prompt) {
        System.out.println("\n" + header);

        for (int i = 0; i < options.length; i++) {
            System.out.println((i+1) + ". " + options[i]);
        }

        while (true) {
            Integer response = getInt(prompt, true);

            int selection = response != null ? response : -1;

            if (selection > 0 && selection <= options.length) {
                return selection;
            } else {
                System.out.println("Invalid menu selection");
            }
        }
    }

    static String getString(String prompt, boolean allowBlank) {
        Scanner s = new Scanner(System.in);

        String response;
        do {
            System.out.println(prompt);
            response = s.nextLine();

            if (!allowBlank && "".equals(response)) {
                response = null;
                System.out.println("Blank entry is not allowed here.");
            }
        } while (null == response);

        return response;
    }

    static Integer getInt(String prompt, boolean allowBlank) {

        int response;
        do {
            String str = getString(prompt, allowBlank);
            if ("".equals(str)) {
                return null;
            }
            try {
                response = Integer.parseInt(str);
                return response;
            } catch (NumberFormatException e) {
                System.out.println("Invalid input - number required");
            }

        } while (true);
    }

    static Boolean getBoolean(String prompt, boolean allowBlank) {
        prompt = prompt + "(y/n) ";
        Boolean response;
        do {
            String str = getString(prompt, allowBlank);
            if ("".equals(str)) {
                return null;
            }

            if ("y".equals(str.toLowerCase())) {
                return true;
            }

            if ("n".equals((str.toLowerCase()))) {
                return false;
            }

            System.out.println("Invalid input - must be y or n");

        } while (true);
    }
}

public class MainDriver {
    public static void main(String[] args) {
        Counter model  = new Counter();
        CounterView view = new CounterView(model);
        CounterController controller = new CounterController(model, view);

        controller.service();
    }
}

模型类

public class CounterController {
    private Counter model;
    private CounterView view;

    public CounterController(Counter model, CounterView view) {
        this.model = model;
        this.view = view;
    }
}

public class Counter {
    private int count = 0;
    private boolean counting = false;
    private Integer ceiling = null;
    private Integer floor = null;
    private boolean reverse = false;

    public void startCounting() {
        counting = true;
        while (counting && checkLimits()) {
            try {
                Thread.sleep(1000);
                count = reverse ? count - 1 : count + 1;

                // You should replace this print with something observable so the View can handle it
                System.err.println(count);
            } catch (InterruptedException ignored) {}
        }
    }

    public void stopCounting() {
        counting = false;
    }

    public void setReverse(boolean reverse) {
        this.reverse = reverse;
    }

    public void setCeiling(Integer ceiling) {
        this.ceiling = ceiling;
    }

    public void setFloor(Integer floor) {
        this.floor = floor;
    }

    public int getCount() {
        return count;
    }

    public void resetCount() {
        count = 0;
    }

    private boolean checkLimits() {
        if (null != ceiling && count >= ceiling) {
            return false;
        }
        if (null != floor && count <= floor) {
            return false;
        }

        return true;
    }
}

public class CounterView {
    private Counter model;

    public CounterView(Counter model) {

        this.model = model;
    }

    public void launch() {

    }
}

    class ViewUtils {
    static int displayMenu(String header, String[] options, String prompt) {
        System.out.println("\n" + header);

        for (int i = 0; i < options.length; i++) {
            System.out.println((i+1) + ". " + options[i]);
        }

        while (true) {
            Integer response = getInt(prompt, true);

            int selection = response != null ? response : -1;

            if (selection > 0 && selection <= options.length) {
                return selection;
            } else {
                System.out.println("Invalid menu selection");
            }
        }
    }

    static String getString(String prompt, boolean allowBlank) {
        Scanner s = new Scanner(System.in);

        String response;
        do {
            System.out.println(prompt);
            response = s.nextLine();

            if (!allowBlank && "".equals(response)) {
                response = null;
                System.out.println("Blank entry is not allowed here.");
            }
        } while (null == response);

        return response;
    }

    static Integer getInt(String prompt, boolean allowBlank) {

        int response;
        do {
            String str = getString(prompt, allowBlank);
            if ("".equals(str)) {
                return null;
            }
            try {
                response = Integer.parseInt(str);
                return response;
            } catch (NumberFormatException e) {
                System.out.println("Invalid input - number required");
            }

        } while (true);
    }

    static Boolean getBoolean(String prompt, boolean allowBlank) {
        prompt = prompt + "(y/n) ";
        Boolean response;
        do {
            String str = getString(prompt, allowBlank);
            if ("".equals(str)) {
                return null;
            }

            if ("y".equals(str.toLowerCase())) {
                return true;
            }

            if ("n".equals((str.toLowerCase()))) {
                return false;
            }

            System.out.println("Invalid input - must be y or n");

        } while (true);
    }
}

public class MainDriver {
    public static void main(String[] args) {
        Counter model  = new Counter();
        CounterView view = new CounterView(model);
        CounterController controller = new CounterController(model, view);

        controller.service();
    }
}

上课前查看

public class CounterController {
    private Counter model;
    private CounterView view;

    public CounterController(Counter model, CounterView view) {
        this.model = model;
        this.view = view;
    }
}

public class Counter {
    private int count = 0;
    private boolean counting = false;
    private Integer ceiling = null;
    private Integer floor = null;
    private boolean reverse = false;

    public void startCounting() {
        counting = true;
        while (counting && checkLimits()) {
            try {
                Thread.sleep(1000);
                count = reverse ? count - 1 : count + 1;

                // You should replace this print with something observable so the View can handle it
                System.err.println(count);
            } catch (InterruptedException ignored) {}
        }
    }

    public void stopCounting() {
        counting = false;
    }

    public void setReverse(boolean reverse) {
        this.reverse = reverse;
    }

    public void setCeiling(Integer ceiling) {
        this.ceiling = ceiling;
    }

    public void setFloor(Integer floor) {
        this.floor = floor;
    }

    public int getCount() {
        return count;
    }

    public void resetCount() {
        count = 0;
    }

    private boolean checkLimits() {
        if (null != ceiling && count >= ceiling) {
            return false;
        }
        if (null != floor && count <= floor) {
            return false;
        }

        return true;
    }
}

public class CounterView {
    private Counter model;

    public CounterView(Counter model) {

        this.model = model;
    }

    public void launch() {

    }
}

    class ViewUtils {
    static int displayMenu(String header, String[] options, String prompt) {
        System.out.println("\n" + header);

        for (int i = 0; i < options.length; i++) {
            System.out.println((i+1) + ". " + options[i]);
        }

        while (true) {
            Integer response = getInt(prompt, true);

            int selection = response != null ? response : -1;

            if (selection > 0 && selection <= options.length) {
                return selection;
            } else {
                System.out.println("Invalid menu selection");
            }
        }
    }

    static String getString(String prompt, boolean allowBlank) {
        Scanner s = new Scanner(System.in);

        String response;
        do {
            System.out.println(prompt);
            response = s.nextLine();

            if (!allowBlank && "".equals(response)) {
                response = null;
                System.out.println("Blank entry is not allowed here.");
            }
        } while (null == response);

        return response;
    }

    static Integer getInt(String prompt, boolean allowBlank) {

        int response;
        do {
            String str = getString(prompt, allowBlank);
            if ("".equals(str)) {
                return null;
            }
            try {
                response = Integer.parseInt(str);
                return response;
            } catch (NumberFormatException e) {
                System.out.println("Invalid input - number required");
            }

        } while (true);
    }

    static Boolean getBoolean(String prompt, boolean allowBlank) {
        prompt = prompt + "(y/n) ";
        Boolean response;
        do {
            String str = getString(prompt, allowBlank);
            if ("".equals(str)) {
                return null;
            }

            if ("y".equals(str.toLowerCase())) {
                return true;
            }

            if ("n".equals((str.toLowerCase()))) {
                return false;
            }

            System.out.println("Invalid input - must be y or n");

        } while (true);
    }
}

public class MainDriver {
    public static void main(String[] args) {
        Counter model  = new Counter();
        CounterView view = new CounterView(model);
        CounterController controller = new CounterController(model, view);

        controller.service();
    }
}

使用“volatile”强制线程计数器检查内存中而不是其“缓存”中的最新设置值

---

嘿你需要发布代码。否则问题就解决了。我可以上传骨架代码吗？这不是一个完全实现的版本是的，当然，但是读者会决定是否有足够的细节来回答。我上传了框架代码！