Fatal编程技术网
  • java/
  • Java 即使存在循环，主线程也会死机

Java 即使存在循环，主线程也会死机

java multithreading

Java 即使存在循环，主线程也会死机,java,multithreading,Java,Multithreading,在主线程中，用户可以在选择获取订单的选项后从控制台发出订单。选择该选项后，我将触发一个线程chef.start（）；负责将客户从队列中取出并准备订单。一旦顺序准备好，我就有了从线程调用的监听器，监听器只显示消息 问题是，即使我的代码是循环的，我的主线程也会死机。我无法提供进一步的输入以请求另一个订单 public class Driver { private static LinkedBlockingQueue<Customer> waitingCustomer=new Li

在主线程中，用户可以在选择获取订单的选项后从控制台发出订单。选择该选项后，我将触发一个线程chef.start（）；负责将客户从队列中取出并准备订单。一旦顺序准备好，我就有了从线程调用的监听器，监听器只显示消息

问题是，即使我的代码是循环的，我的主线程也会死机。我无法提供进一步的输入以请求另一个订单

public class Driver {
    private static LinkedBlockingQueue<Customer> waitingCustomer=new LinkedBlockingQueue<Customer>();


    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        OrderPrepared op=new OrderPrepared(waitingCustomer);

        while (true) {
            System.out.println("would you like to place new Order Press Y or N");
            String input = sc.nextLine();
            if ("y".equalsIgnoreCase(input)) {
                Customer customer = null;
                System.out.println("Enter Customer Name");
                String name = sc.nextLine();
                System.out.println("What would you like to order");
                System.out.println(" ");
                System.out.println("Our Menu Card ");
                System.out.println(" ");
                System.out.println("Item Name\t\t" + "     Price\t\t" + "Press to order");
                System.out.println(" ");
                System.out.println("Cheese And Tomato\t\t" + "60\t\t" + "1");
                System.out.println("Margerita        \t\t" + "40\t\t" + "2");
                System.out.println("Burger           \t\t" + "50\t\t" + "3");
                System.out.println("Chicken Fried    \t\t" + "90\t\t" + "4");
                System.out.println(" ");
                System.out.println("Please Press Number to place order");
                int number=sc.nextInt();
                Food food=null;

                switch(number) {
                case 1: 
                    food=new Food("Cheese And Tomato", 60.0d);
                case 2:
                    food=new Food("Margerita", 40.0d);
                case 3:
                    food=new Food("Burger", 50.0d);
                case 4:
                    food=new Food("Chicken Fried", 90.0d);
                }
                Random ran=new Random(709);
                customer=new Customer(name,new Order(ran.nextInt(), food));
                waitingCustomer.add(customer);
                Chef chef=new Chef();
                chef.setChefListener(op);
                chef.setCustomers(waitingCustomer);
                chef.setFood(food);
                chef.start();

            } else {
                break;
            }
        }

    }

}


public class Chef extends Thread {


    Food food;
    ChefListener chefListener;
    LinkedBlockingQueue<Customer> customers;

    public Chef() {

    }
    public Chef(Food piza, ChefListener chefListener, LinkedBlockingQueue<Customer> customers) {
        super();
        this.food = piza;
        this.chefListener = chefListener;
        this.customers = customers;
    }

    @Override
    public void run() {
        // TODO Auto-generated method stub
        for (Customer customer : customers) {
            chefListener.pizzaCooked(customer, food);
            customers.remove();
            System.out.println("customer has been removed from queue");
        }

    }
    public Food getFood() {
        return food;
    }

    public void setFood(Food food) {
        this.food = food;
    }

    public ChefListener getChefListener() {
        return chefListener;
    }

    public void setChefListener(ChefListener chefListener) {
        this.chefListener = chefListener;
    }

    public LinkedBlockingQueue<Customer> getCustomers() {
        return customers;
    }

    public void setCustomers(LinkedBlockingQueue<Customer> customers) {
        this.customers = customers;
    }
}



public class OrderPrepared implements ChefListener{
    Logger logger=Logger.getLogger("OrderPrepared");
    public OrderPrepared(LinkedBlockingQueue<Customer> waitingCustomer) {

    }

    @Override
    public void pizzaCooked(Customer customer, Food food) {
        // TODO Auto-generated method stub
        logger.info(customer.getName()+" "+food.getName() + " has been cooked. Enjoy");

    }

}


Output
import java.util.concurrent.LinkedBlockingQueue;
import java.util.logging.Logger;

public class OrderPrepared implements ChefListener{
    Logger logger=Logger.getLogger("OrderPrepared");
    public OrderPrepared(LinkedBlockingQueue<Customer> waitingCustomer) {
        // TODO Auto-generated constructor stub
    }

    @Override
    public void pizzaCooked(Customer customer, Food food) {
        // TODO Auto-generated method stub
        logger.info(customer.getName()+" "+food.getName() + " has been cooked. Enjoy");

    }

}

Output

would you like to place new Order Press Y or N
Y
Enter Customer Name
Kalis
What would you like to order

Our Menu Card 

Item Name            Price      Press to order

Cheese And Tomato       60      1
Margerita               40      2
Burger                  50      3
Chicken Fried           90      4

Please Press Number to place order
2
would you like to place new Order Press Y or N
customer has been removed from queue
Nov 12, 2019 2:32:45 AM OrderPrepared pizzaCooked
INFO: Kalis Chicken Fried has been cooked. Enjoy

公共类驱动程序{
私有静态LinkedBlockingQueue waitingCustomer=新LinkedBlockingQueue（）；
公共静态void main（字符串[]args）{
扫描仪sc=新的扫描仪（System.in）；
OrderPrepared op=已准备好的新订单（waitingCustomer）；
while（true）{
System.out.println（“您想下新订单，按Y还是按N”）；
字符串输入=sc.nextLine（）；
如果（“y”。相等信号情况（输入））{
客户=空；
System.out.println（“输入客户名称”）；
字符串名称=sc.nextLine（）；
System.out.println（“您想要点什么”）；
System.out.println（“”）；
System.out.println（“我们的菜单卡”）；
System.out.println（“”）；
System.out.println（“项目名称\t\t“+”价格\t\t“+”按订单”）；
System.out.println（“”）；
System.out.println（“奶酪和番茄”+“60\t\t”+“1”）；
System.out.println（“Margerita\t\t”+“40\t\t”+“2”）；
System.out.println（“Burger\t\t”+“50\t\t”+“3”）；
System.out.println（“炸鸡”+“90\t\t”+“4”）；
System.out.println（“”）；
System.out.println（“请按数字下单”）；
int number=sc.nextInt（）；
食物=零；
开关（编号）{
案例1：
食品=新食品（“奶酪和番茄”，60.0d）；
案例2：
食品=新食品（“玛格丽塔”，40.0d）；
案例3：
食品=新食品（“汉堡”，50.0d）；
案例4：
食品=新食品（“炸鸡”，90.0d）；
}
随机运行=新随机（709）；
客户=新客户（名称，新订单（ran.nextInt（），food））；
waitingCustomer.add（客户）；
厨师长=新厨师（）；
厨师长塞切弗利斯滕纳（op）；
厨师长：设置顾客（等待顾客）；
厨师长.食物（食物）；
chef.start（）；
}否则{
打破
}
}
}
}
公共类扩展线程{
食品；
ChefListener ChefListener；
LinkedBlockingQueue客户；
主厨（）{
}
公共厨师（食品皮萨、切弗利斯滕、LinkedBlockingQueue客户）{
超级（）；
这个食物=比萨；
this.chefListener=chefListener；
这是。顾客=顾客；
}
@凌驾
公开募捐{
//TODO自动生成的方法存根
用于（客户：客户）{
chefListener.比萨饼熟（顾客、食物）；
客户。删除（）；
System.out.println（“客户已从队列中删除”）；
}
}
公共食品{
归还食物；
}
公共食品（食品）{
这就是食物；
}
公共ChefListener getChefListener（）{
返回chefListener；
}
公共无效设置ChefListener（ChefListener ChefListener）{
this.chefListener=chefListener；
}
公共LinkedBlockingQueue getCustomers（）{
返回客户；
}
公共无效集合客户（LinkedBlockingQueue客户）{
这是。顾客=顾客；
}
}
公共类OrderPrepared实现了ChefListener{
Logger=Logger.getLogger（“OrderPrepared”）；
已准备好公共订单（LinkedBlockingQueue waitingCustomer）{
}
@凌驾
已煮熟的公共空比萨饼（顾客、食物）{
//TODO自动生成的方法存根
logger.info（customer.getName（）+“”+food.getName（）+“已经煮熟了。享受”）；
}
}
输出
导入java.util.concurrent.LinkedBlockingQueue；
导入java.util.logging.Logger；
公共类OrderPrepared实现了ChefListener{
Logger=Logger.getLogger（“OrderPrepared”）；
已准备好公共订单（LinkedBlockingQueue waitingCustomer）{
//TODO自动生成的构造函数存根
}
@凌驾
已煮熟的公共空比萨饼（顾客、食物）{
//TODO自动生成的方法存根
logger.info（customer.getName（）+“”+food.getName（）+“已经煮熟了。享受”）；
}
}
输出
您想按Y或N下新订单吗
Y
输入客户名称
卡利斯
您想要点什么
我们的菜单卡
商品名称价格按订单
奶酪和番茄60 1
玛格丽塔40 2
汉堡503
炸鸡904
请按号码下单
2.
您想按Y或N下新订单吗
客户已从队列中删除
2019年11月12日凌晨2:32:45准备好的比萨饼
信息：卡利斯炸鸡已经做好了。享受
nextInt（）不使用LF。使用nextLine（）跟随nextInt（），以便使用行终止符（lf）。否则，循环顶部的下一行将以空行退出

也看到