Java并发编程实践简单案例-顾客排队

一个简单的Java并发编程实践案例是使用多线程实现顾客排队系统。

在这个案例中，我们可以创建一个有限容量的阻塞队列CustomerLine，用于模拟顾客的排队队列。然后，我们可以创建两个线程，一个代表顾客CustomerGenerator，另一个代表出纳员Teller。

CustomerGenerator线程会生成一定数量的顾客，并将他们加入到CustomerLine中。Teller线程则会从CustomerLine中取出顾客进行服务。在这个过程中，我们可以通过使用synchronized关键字或者Lock来实现线程间的同步和协作。

这个案例可以帮助我们理解Java并发编程中的线程同步和通信机制，以及如何使用Java提供的并发工具类来实现这些机制。同时，我们也可以通过这个案例来学习如何设计并发程序，以及如何优化程序的性能和响应速度。

import java.util.concurrent.BlockingQueue;  
import java.util.concurrent.LinkedBlockingQueue;  
  
class Customer {  
    private String name;  
  
    public Customer(String name) {  
        this.name = name;  
    }  
  
    public String getName() {  
        return name;  
    }  
}  
  
class CustomerGenerator extends Thread {  
    private BlockingQueue<Customer> queue;  
    private int maxCustomers;  
  
    public CustomerGenerator(BlockingQueue<Customer> queue, int maxCustomers) {  
        this.queue = queue;  
        this.maxCustomers = maxCustomers;  
    }  
  
    @Override  
    public void run() {  
        for (int i = 0; i < maxCustomers; i++) {  
            try {  
                Thread.sleep(1000); // 休眠一段时间来模拟顾客的生成过程  
                queue.put(new Customer("Customer " + i)); // 将顾客加入到队列中  
                System.out.println("Generated customer: " + queue.take().getName()); // 打印生成顾客的信息，这里使用队列的take方法来阻塞等待队列非空  
            } catch (InterruptedException e) {  
                e.printStackTrace();  
            }  
        }  
    }  
}  
  
class Teller extends Thread {  
    private BlockingQueue<Customer> queue;  
  
    public Teller(BlockingQueue<Customer> queue) {  
        this.queue = queue;  
    }  
  
    @Override  
    public void run() {  
        while (true) {  
            try {  
                Customer customer = queue.take(); // 从队列中取出顾客进行服务，这里使用队列的take方法来阻塞等待队列非空  
                System.out.println("Serviced customer: " + customer.getName()); // 打印服务顾客的信息  
            } catch (InterruptedException e) {  
                e.printStackTrace();  
            }  
        }  
    }  
}  
  
public class ConcurrencyExample {  
    public static void main(String[] args) {  
        int maxCustomers = 10; // 最大顾客数量为10  
        BlockingQueue<Customer> queue = new LinkedBlockingQueue<>(maxCustomers); // 使用阻塞队列来模拟排队队列，容量为maxCustomers  
        CustomerGenerator generator = new CustomerGenerator(queue, maxCustomers); // 创建顾客生成线程，将生成的顾客加入到队列中  
        Teller teller = new Teller(queue); // 创建出纳员线程，从队列中取出顾客进行服务  
        generator.start(); // 启动顾客生成线程，生成一定数量的顾客并加入到队列中，直到队列满为止（阻塞等待）  
        teller.start(); // 启动出纳员线程，从队列中取出顾客进行服务，直到程序退出（无限循环）  
    }  
}