使用java模拟三个窗口同时卖电影票的程序，电影票有第几排第几号两个参数，接受单张和联票（就是2-10张连续座位的票）两种订单。

好的，这是一个比较典型的多线程编程问题，可以使用Java中的线程和同步机制来实现。以下是一个简单的实现：

import java.util.ArrayList;

// 电影票类
class Ticket {
    private int row; // 座位行数
    private int number; // 座位号

    public Ticket(int row, int number) {
        this.row = row;
        this.number = number;
    }

    public int getRow() {
        return row;
    }

    public int getNumber() {
        return number;
    }
}

// 订单类
class Order {
    private ArrayList<Ticket> tickets; // 票的列表

    public Order() {
        tickets = new ArrayList<Ticket>();
    }

    public void addTicket(Ticket ticket) {
        tickets.add(ticket);
    }

    public ArrayList<Ticket> getTickets() {
        return tickets;
    }
}

// 窗口类
class Window extends Thread {
    private static int MAX_SEATS = 100; // 总共可售座位数
    private static int MAX_CONSECUTIVE_SEATS = 10; // 最大连续座位数
    private static Object lock = new Object(); // 同步锁

    private String name; // 窗口名称
    private ArrayList<Ticket> seats; // 座位列表

    public Window(String name) {
        this.name = name;
        seats = new ArrayList<Ticket>();
    }

    // 售票方法
    public void sell(Order order) {
        synchronized (lock) { // 同步锁，保证多个窗口不会同时卖同一张票
            ArrayList<Ticket> tickets = order.getTickets();
            for (Ticket ticket : tickets) {
                if (seats.contains(ticket)) { // 检查座位是否已售出
                    System.out.println(name + ": " + ticket.getRow() + "排" + ticket.getNumber() + "号座位已售出，请选择其他座位！");
                } else if (isConsecutiveSeats(ticket)) { // 检查是否连续座位
                    int startNumber = ticket.getNumber() - MAX_CONSECUTIVE_SEATS + 1;
                    boolean isAvailable = true;
                    for (int i = startNumber; i <= ticket.getNumber(); i++) {
                        Ticket t = new Ticket(ticket.getRow(), i);
                        if (seats.contains(t)) { // 检查连续座位是否已售出
                            isAvailable = false;
                            break;
                        }
                    }
                    if (isAvailable) { // 连续座位可售，加入座位列表
                        for (int i = startNumber; i <= ticket.getNumber(); i++) {
                            Ticket t = new Ticket(ticket.getRow(), i);
                            seats.add(t);
                        }
                        System.out.println(name + ": " + ticket.getRow() + "排" + startNumber + "-" + ticket.getNumber() + "号座位已售出！");
                    } else { // 连续座位不可售
                        System.out.println(name + ": " + ticket.getRow() + "排" + ticket.getNumber() + "号座位不可售，请选择其他座位！");
                    }
                } else if (seats.size() >= MAX_SEATS) { // 检查座位是否已满
                    System.out.println(name + ": 座位已满，请选择其他场次！");
                } else { // 单张座位可售，加入座位列表
                    seats.add(ticket);
                    System.out.println(name + ": " + ticket.getRow() + "排" + ticket.getNumber() + "号座位已售出！");
                }
            }
        }
    }

    // 检查是否连续座位
    private boolean isConsecutiveSeats(Ticket ticket) {
        int count = 1;
        for (int i = ticket.getNumber() - 1; i >= 1; i--) {
            Ticket t = new Ticket(ticket.getRow(), i);
            if (seats.contains(t)) {
                count++;
            } else {
                break;
            }
            if (count >= MAX_CONSECUTIVE_SEATS) {
                break;
            }
        }
        for (int i = ticket.getNumber() + 1; i <= 10; i++) {
            Ticket t = new Ticket(ticket.getRow(), i);
            if (seats.contains(t)) {
                count++;
            } else {
                break;
            }
            if (count >= MAX_CONSECUTIVE_SEATS) {
                break;
            }
        }
        return count >= MAX_CONSECUTIVE_SEATS;
    }

    // 获取已售座位
    public ArrayList<Ticket> getSoldSeats() {
        return seats;
    }

    @Override
    public void run() {
        System.out.println(name + "已开启！");
    }
}

// 主程序
public class Main {
    public static void main(String[] args) throws InterruptedException {
        Window window1 = new Window("窗口1");
        Window window2 = new Window("窗口2");
        Window window3 = new Window("窗口3");

        window1.start();
        window2.start();
        window3.start();

        // 模拟售票
        Order order1 = new Order();
        order1.addTicket(new Ticket(1, 1));
        window1.sell(order1);

        Order order2 = new Order();
        order2.addTicket(new Ticket(2, 5));
        order2.addTicket(new Ticket(2, 6));
        window2.sell(order2);

        Order order3 = new Order();
        order3.addTicket(new Ticket(3, 7));
        order3.addTicket(new Ticket(3, 8));
        order3.addTicket(new Ticket(3, 9));
        order3.addTicket(new Ticket(3, 10));
        window3.sell(order3);

        Order order4 = new Order();
        order4.addTicket(new Ticket(4, 1));
        order4.addTicket(new Ticket(4, 2));
        order4.addTicket(new Ticket(4, 3));
        window1.sell(order4);

        Order order5 = new Order();
        order5.addTicket(new Ticket(5, 5));
        order5.addTicket(new Ticket(5, 6));
        order5.addTicket(new Ticket(5, 7));
        order5.addTicket(new Ticket(5, 8));
        order5.addTicket(new Ticket(5, 9));
        order5.addTicket(new Ticket(5, 10));
        window2.sell(order5);

        // 等待所有窗口售票结束
        window1.join();
        window2.join();
        window3.join();

        // 输出已售座位
        System.out.println("窗口1已售出的座位：" + window1.getSoldSeats());
        System.out.println("窗口2已售出的座位：" + window2.getSoldSeats());
        System.out.println("窗口3已售出的座位：" + window3.getSoldSeats());
    }
}

在这个程序中，我们定义了三个窗口（Window），每个窗口都是一个线程，可以同时卖票。每个窗口有一个座位列表（seats），记录已售出的座位。当一个顾客购买电影票时，我们将其订单（Order）传递给窗口的售票方法（sell）进行处理。在售票方法中，我们使用同步锁来保证多个窗口不会同时卖同一张票，并且使用座位列表来检查座位是否已售出、是否连续座位以及座位是否已满等情况，然后将可售座位加入座位列表中。最后，我们等待所有窗口的售票结束，并输出已售出的座位列表。