While循环提前终止问题：煎饼生产任务剩余1个未被食用

问题根源分析 #

1. 全局状态被错误重置：producePancake方法每次调用都会将consumedPancake、availablePancake、totalPancakeProduced重置为0，导致生产和食用的状态跟踪完全混乱，刚生产的煎饼状态直接丢失。
2. 循环提前终止：当totalPancakeProduced达到12时，循环直接执行break退出，没有给用户食用最后一个煎饼的机会。
3. 语法错误：eatPancake方法中Collections.shuffle(usersList)语句缺少分号，会导致编译失败。

修复方案 #

1. 迁移全局状态初始化：将状态变量的初始化移到performTask方法中，确保生产和食用的状态持续被跟踪。
2. 调整循环逻辑：生产满12个煎饼后，循环不直接终止，而是继续执行食用逻辑，直到没有剩余煎饼或时间结束。
3. 优化食用逻辑：在eatPancake中增加煎饼可用性判断，避免无意义的递归调用；同步更新已食用煎饼计数，确保数据准确。
4. 修复语法错误：补充Collections.shuffle(usersList)后的分号。

修改后的完整代码 #

import java.time.Instant;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;

public class PanCakeTask {

    int consumedPancake;
    int availablePancake;
    int totalPancakeProduced;
    List<String> usersList = new ArrayList<>();

    void producePancake(HashMap<String, Integer> users) {
        if (totalPancakeProduced < 12) {
            // 实时计算已食用总数
            consumedPancake = 0;
            for (String user : users.keySet()) {
                consumedPancake += users.get(user);
            }

            System.out.println("Pancake produced");
            availablePancake += 1;
            totalPancakeProduced = consumedPancake + availablePancake;

            eatPancake(users);
        }
    }

    void eatPancake(HashMap<String, Integer> users) {
        // 仅当有可用用户和煎饼时执行食用逻辑
        if (usersList.size() >= 1 && availablePancake >= 1) {
            System.out.println("The list is " + usersList);
            Collections.shuffle(usersList); // 修复语法错误

            int numberEaten = users.get(usersList.get(0));

            if (numberEaten >= 5) {
                usersList.remove(0);
                eatPancake(users); // 递归寻找可食用用户
            } else {
                // 执行食用操作并更新状态
                int newCount = numberEaten + 1;
                availablePancake -= 1;
                consumedPancake += 1;
                users.put(usersList.get(0), newCount);
            }
        }
    }

    public void performTask() {
        HashMap<String, Integer> users = new HashMap<>();
        users.put("user1", 0);
        users.put("user2", 0);
        users.put("user3", 0);

        usersList.addAll(users.keySet());

        System.out.println(users);
        System.out.println(usersList);

        // 初始化全局状态变量
        consumedPancake = 0;
        availablePancake = 0;
        totalPancakeProduced = 0;

        Instant stop = Instant.now().plusSeconds(20);
        System.out.println("The starting time is " + Instant.now());

        while (stop.isAfter(Instant.now())) {
            if (totalPancakeProduced < 12) {
                producePancake(users);
            } else {
                // 生产满额后，仅处理剩余煎饼的食用
                if (availablePancake > 0) {
                    eatPancake(users);
                } else {
                    // 无剩余煎饼时提前退出
                    break;
                }
            }
            // 短暂休眠避免CPU占用过高
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                break;
            }
        }

        int available = totalPancakeProduced - consumedPancake;
        System.out.println("The ending time is " + Instant.now());
        System.out.println("Total number of cake produced is " + totalPancakeProduced);
        System.out.println("Total number of cake eaten is " + consumedPancake);
        System.out.println("Total number of pancake remained is " + available);
    }

    public static void main(String[] args) {
        new PanCakeTask().performTask();
    }
}

关键修改说明 #

• 将状态变量初始化移到performTask，确保生产过程中状态持续跟踪。
• 循环逻辑调整为：生产满12个后，优先处理剩余煎饼的食用，直到无煎饼或时间结束。
• 在eatPancake中增加双重判断，避免无效递归；同步更新consumedPancake，保证计数准确。
• 添加Thread.sleep(100)，避免循环过度占用系统资源。

内容的提问来源于stack exchange，提问作者Ukeme Elijah