Question

我正在尝试使用Java模拟购物中心中的一组Checkout计数器。

这是假设。有5个结帐柜台。就像一个真正的购物中心一样，每个柜台上都有一条线。每个柜台一次服务一个客户。

我尝试如下实现此目标：

每个客户都是运行类似于生产者-消费者问题中的生产者的线程的类。客户是阻塞队列的一部分。我将需要一组阻塞队列来模拟5个结帐柜台前的5行。我该如何实现。
结帐计数器已定义为单线程执行器服务。因此，现在将有5个执行程序，它们一次将服务一个（生产者）线程。我已经定义了一个执行者数组列表来模拟这组5。
在计数器处，执行程序服务正在一次执行来自相应队列的一个线程（即，消费者正在消耗生产者生产的东西）。

我的逻辑正确吗？

我有一些代码，但是我不确定此代码是否正确执行了我的逻辑。

请帮助。干杯。

代码：

Checkout.java

package Supermarket;

import java.util.*;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;

public class Checkout implements Runnable
{
    public BlockingQueue<Integer> item_queue = new ArrayBlockingQueue<Integer>(10);

    public int checkout_number;
    public int item;

    public Random random;

    public Checkout(int checkout_number, BlockingQueue<Integer> item_queue)
    {
        this.checkout_number = checkout_number;
        this.item_queue = item_queue;

        random = new Random();
        System.out.println("\nCheckout Counter Number: "+checkout_number);
    }

    public void run()
    {
        while(true)
        {           
            if(item == -1)
            {
                System.out.println("Consumer finished");
                break;
            }
            else
            {
                try 
                {
                    item = item_queue.take();
                } 
                catch (InterruptedException e) 
                {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }

                System.out.println("\nConsumer has taken item ==> "+item);
                System.out.println("Scanning item");

                try 
                {
                    Thread.sleep(random.nextInt(5000));
                } 
                catch (InterruptedException e)
                {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }
    }

}

Customer.java

    package Supermarket;

import java.util.*;
import java.util.concurrent.*;

public class Customer implements Runnable
{

    public int item;
    public int customer_number;
    public int i;
    public int item_count;

    public Random random = new Random();
    public BlockingQueue<Integer> item_queue = new ArrayBlockingQueue<Integer>(10);

    public Customer(int customer_number, BlockingQueue<Integer> item_queue)
    {
        this.customer_number = customer_number;
        this.item_queue = item_queue;
    }

    public void run()
    {
        item_count = random.nextInt(5);

        System.out.println("I am customer Number: "+customer_number+" and I have "+item_count+" items");

        for(i=0; i<item_count; i++)
        {
            try 
            {
                item_queue.put(random.nextInt(10));
            } 
            catch (InterruptedException e) 
            {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }

        try 
        {
            item_queue.put(-1);
        } 
        catch (InterruptedException e) 
        {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

Driver.java

package Supermarket;

import java.util.concurrent.*;
import java.util.*;

public class Driver 
{
    public static BlockingQueue<Integer> item_queue = new ArrayBlockingQueue<Integer>(10);

    public static Random random = new Random();

    public static int customer_count;
    public static int checkout_count;
    public static int i;

    public static void main(String[] args) {
        // TODO Auto-generated method stub

        customer_count = random.nextInt(4)+1;
//      checkout_count = 5;

        System.out.println("Total Number of Customers: "+customer_count+"\n");

            for(i=0; i<customer_count; i++)
            {
                Customer customer = new Customer(i+1, item_queue);
                Thread customer_thread = new Thread(customer);
                customer_thread.start();
            }

//          for(i=0; i<=checkout_count; i++)
//          {
//              Checkout checkout = new Checkout(1, item_queue);
//              Thread checkout_thread = new Thread(checkout);
//              checkout_thread.start();
//          }

//      System.out.println("\n\nProgram Terminates!\n\n");
    }

}

Answer 1

您的模拟可能需要考虑其他一些功能。例如，您可能需要考虑以下一些或全部设计注意事项：

客户

每个客户都有以下特征

一组要购买的物品。
- 所有商品都是通过一次交易购买的，而不是一次购买
- 单笔交易中可能有0 .. *件商品。
- 一项0项交易的收据为$ 0.00。
客户识别
到达结帐行的时间
完成结帐交易的时间
购买交易的价值（即收据）

结帐柜台

每个结帐柜台具有以下特征

等待结帐的客户的队列。
队列中可能有0 .. *个客户正在等待结账
队列中的客户数可供每个客户使用在进入队列之前
客户总是选择可用的最短结帐队列
在结帐队列中，所有客户都会留在该队列中，直到他们的交易已完成。
结帐柜台ID
自商店开业以来的顾客人数统计
- 0项交易不会增加所服务客户的计数
结帐柜台处理的所有销售总额

商店库存

可购买的一组商品是商店库存。每个项目都具有以下特征

商品ID
物品成本

客户购买的一组商品仅包含每个商品的商品ID。特定的商品ID在客户选择购买的商品列表中可能会出现多次。

Answer 2

我的逻辑如下：

将结帐计数器写为自己的线程
将该行（客户行）写为常规列表。不必是BlockingDeque，因为每个结帐柜台都处理自己的行。

通过这种方式，它将像真正的超市一样工作，每个结帐柜台都处理自己的行。

基于此，我认为编写代码应该更具逻辑性。

Java并发编程。尝试模拟一组结帐计数器

2 个答案: