2. 编写程序模拟铁路售票系统，采用实现Runnable接口的方法实现通过3个代售点发售某日某次列车的50张票。

### 回答1：
以下是一个简单的铁路售票系统的模拟程序：

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class TicketSystem implements Runnable {
    private static int totalTickets = 50; // 总票数
    private static Lock lock = new ReentrantLock(); // 锁对象
    private String sellerName; // 代售点名称

    public TicketSystem(String sellerName) {
        this.sellerName = sellerName;
    }

    @Override
    public void run() {
        while (totalTickets > 0) {
            try {
                lock.lock(); // 获取锁
                if (totalTickets > 0) {
                    System.out.println(sellerName + "卖出了一张票，剩余票数：" + --totalTickets);
                }
            } finally {
                lock.unlock(); // 释放锁
            }
        }
    }

    public static void main(String[] args) {
        Thread t1 = new Thread(new TicketSystem("代售点1"));
        Thread t2 = new Thread(new TicketSystem("代售点2"));
        Thread t3 = new Thread(new TicketSystem("代售点3"));
        t1.start();
        t2.start();
        t3.start();
    }
}

程序中使用了一个静态变量 `totalTickets` 来表示总票数，每个线程代表一个售票点，当总票数大于 0 时，就可以进行售票。在售票时需要加锁，以保证多个售票点不会同时卖出同一张票。程序中使用了 `ReentrantLock` 来实现锁的功能。当售票完成后，需要释放锁，以便其他售票点可以继续售票。

### 回答2：
编写程序模拟铁路售票系统可以通过实现Runnable接口的方法来实现。首先创建一个Ticket类，用于表示票的信息，包括票号、车次、日期等属性。然后创建一个TicketCounter类，实现Runnable接口，代表一个售票代理点。

在TicketCounter类中，定义一个静态的票池，用来存储待售的票。在run方法中，使用synchronized关键字对票池进行同步处理，以避免多个售票代理点同时售卖同一张票。具体的售票过程如下：

1. 判断票池中是否还有票可售。如果没有，则结束售票。
2. 从票池中取出一张待售的票，并更新票的状态为“已售”。
3. 打印出售票的信息，包括代售点、票号、车次、日期等。
4. 通过Thread.sleep方法模拟售票的时间。
5. 售票完成后，将票的信息存入日志文件中。

在主程序中，创建三个售票代理点，并分别以它们为参数创建三个线程。然后通过线程的start方法启动这三个代售点的售票过程。

最后，在主程序中使用join方法，确保程序等待所有售票线程执行完毕后再结束，并输出售票结束的提示信息。

这样就能够模拟铁路售票系统，通过三个代售点发售某日某次列车的50张票。售票过程中通过实现Runnable接口、同步处理和模拟时间等方式，更贴近实际的售票系统运作情景。

### 回答3：
铁路售票系统的模拟程序可以通过实现Runnable接口的方式来实现。首先，我们需要创建一个Ticket类来表示每张票，包括票的编号、代售点编号和座位号等信息。接着，我们创建一个代售点类，代售点类实现Runnable接口，表示一个代售点的售票过程。

在代售点的售票过程中，我们使用一个静态变量count来表示已售出的票数量，初始值为0。在售票过程中，使用一个循环来判断是否还有票可售，如果还有票可售，则创建一个新的Ticket对象，设置相关信息并将其添加到一个共享的集合票集合中，同时将count加1。在售票过程中，使用synchronized关键字来确保多个代售点之间的售票互斥，避免出现多个代售点同时售出同一张票的情况。

最后，创建三个代售点对象，分别作为线程启动并运行。每个代售点在其run方法中执行售票过程。当票数达到50张时，停止售票。

具体的代码如下：

public class Ticket {
    private String ticketNo;
    private int agentNo;
    private int seatNo;

    public Ticket(String ticketNo, int agentNo, int seatNo) {
        this.ticketNo = ticketNo;
        this.agentNo = agentNo;
        this.seatNo = seatNo;
    }

    // 省略getter和setter方法
}

public class TicketAgent implements Runnable {
    private static final int MAX_TICKETS = 50;
    private static int count = 0;
    private int agentNo;
    private List<Ticket> tickets;

    public TicketAgent(int agentNo) {
        this.agentNo = agentNo;
        this.tickets = new ArrayList<>();
    }

    @Override
    public void run() {
        while (count < MAX_TICKETS) {
            synchronized (TicketAgent.class) {
                if (count < MAX_TICKETS) {
                    String ticketNo = "Ticket" + (count + 1);
                    int seatNo = count + 1;
                    Ticket ticket = new Ticket(ticketNo, agentNo, seatNo);
                    tickets.add(ticket);
                    count++;
                    System.out.println("代售点" + agentNo + "售出了" + ticketNo);
                }
            }

            try {
                Thread.sleep(100); // 模拟代售点售票的时间
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    // 省略getter方法
}

public class Main {
    public static void main(String[] args) {
        TicketAgent agent1 = new TicketAgent(1);
        TicketAgent agent2 = new TicketAgent(2);
        TicketAgent agent3 = new TicketAgent(3);

        Thread thread1 = new Thread(agent1);
        Thread thread2 = new Thread(agent2);
        Thread thread3 = new Thread(agent3);

        thread1.start();
        thread2.start();
        thread3.start();
    }
}

以上是一个简单的铁路售票系统的模拟程序，通过三个代售点实现对某日某次列车50张票的发售。每个代售点通过售票过程来创建并售出票，并将已售出的票添加到一个集合中，最多售票数为50张。请适当调整代码以符合实际需求和约束。