java如何叫号

叫号系统的实现方法

在Java中实现叫号系统，可以通过多线程和队列管理来模拟实际场景。以下是几种常见的实现方式：

基于队列的叫号系统

使用Queue接口及其实现类LinkedList来管理排队号码：

import java.util.LinkedList;
import java.util.Queue;

public class NumberCallSystem {
    private Queue<Integer> queue = new LinkedList<>();
    private int currentNumber = 1;

    public synchronized int getNumber() {
        queue.offer(currentNumber);
        return currentNumber++;
    }

    public synchronized Integer callNext() {
        return queue.poll();
    }
}

多线程叫号系统

模拟多个服务窗口同时叫号的场景：

public class TicketWindow implements Runnable {
    private NumberCallSystem system;

    public TicketWindow(NumberCallSystem system) {
        this.system = system;
    }

    @Override
    public void run() {
        while(true) {
            Integer number = system.callNext();
            if(number != null) {
                System.out.println(Thread.currentThread().getName() + " calling: " + number);
            }
            try {
                Thread.sleep(1000); // 模拟处理时间
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

使用线程池管理

通过线程池管理多个叫号窗口：

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Main {
    public static void main(String[] args) {
        NumberCallSystem system = new NumberCallSystem();
        ExecutorService executor = Executors.newFixedThreadPool(3); // 3个窗口

        for(int i=0; i<3; i++) {
            executor.execute(new TicketWindow(system));
        }

        // 模拟用户取号
        for(int i=0; i<10; i++) {
            System.out.println("New ticket: " + system.getNumber());
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

高级功能实现

优先级叫号系统

为特殊客户（如VIP）实现优先叫号：

import java.util.PriorityQueue;

public class PriorityNumberCallSystem {
    private PriorityQueue<Customer> queue = new PriorityQueue<>();
    private int currentNumber = 1;

    public synchronized int getNumber(boolean isVip) {
        Customer customer = new Customer(currentNumber++, isVip);
        queue.offer(customer);
        return customer.number;
    }

    public synchronized Customer callNext() {
        return queue.poll();
    }

    class Customer implements Comparable<Customer> {
        int number;
        boolean isVip;

        public Customer(int number, boolean isVip) {
            this.number = number;
            this.isVip = isVip;
        }

        @Override
        public int compareTo(Customer other) {
            if(this.isVip && !other.isVip) return -1;
            if(!this.isVip && other.isVip) return 1;
            return Integer.compare(this.number, other.number);
        }
    }
}

数据库持久化

将排队信息保存到数据库：

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;

public class DatabaseNumberCallSystem {
    private Connection conn;

    public DatabaseNumberCallSystem() throws Exception {
        conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/queue_db", "user", "password");
    }

    public int getNumber() throws Exception {
        PreparedStatement stmt = conn.prepareStatement("INSERT INTO queue (status) VALUES ('waiting')", PreparedStatement.RETURN_GENERATED_KEYS);
        stmt.executeUpdate();
        ResultSet rs = stmt.getGeneratedKeys();
        if(rs.next()) {
            return rs.getInt(1);
        }
        return -1;
    }

    public Integer callNext() throws Exception {
        PreparedStatement stmt = conn.prepareStatement("SELECT id FROM queue WHERE status='waiting' ORDER BY id LIMIT 1");
        ResultSet rs = stmt.executeQuery();
        if(rs.next()) {
            int id = rs.getInt("id");
            PreparedStatement updateStmt = conn.prepareStatement("UPDATE queue SET status='processing' WHERE id=?");
            updateStmt.setInt(1, id);
            updateStmt.executeUpdate();
            return id;
        }
        return null;
    }
}

这些实现方式可以根据实际需求进行组合和扩展，构建适合不同场景的叫号系统。