用Java语言编写一个程序，创建两个线程，模拟售票的过程。在输出结果时，要显示是哪个线程售出的票。

### 回答1：
以下是一个简单的 Java 程序，用来模拟售票过程并显示是哪个线程售出的票：

public class TicketSeller {
    public static void main(String[] args) {
        // 创建一个票池，共有 100 张票
        TicketPool ticketPool = new TicketPool(100);

        // 创建两个售票线程
        TicketSellerThread seller1 = new TicketSellerThread("售票员1", ticketPool);
        TicketSellerThread seller2 = new TicketSellerThread("售票员2", ticketPool);

        // 启动两个售票线程
        seller1.start();
        seller2.start();
    }
}

class TicketPool {
    private int tickets;

    public TicketPool(int tickets) {
        this.tickets = tickets;
    }

    // 售票方法，返回是否售票成功
    public synchronized boolean sellTicket(String sellerName) {
        if (tickets > 0) {
            System.out.println(sellerName + "售出了一张票，剩余票数：" + --tickets);
            return true;
        } else {
            System.out.println(sellerName + "没有票可以售出了！");
            return false;
        }
    }
}

class TicketSellerThread extends Thread {
    private String sellerName;
    private TicketPool ticketPool;

    public TicketSellerThread(String sellerName, TicketPool ticketPool) {
        this.sellerName = sellerName;
        this.ticketPool = ticketPool;
    }

    @Override
    public void run() {
        while (ticketPool.sellTicket(sellerName)) {
            // 售票成功，继续售票
        }
    }
}

在这个程序中，我们定义了一个 `TicketPool` 类来表示票池，其中包含一个 `sellTicket()` 方法来模拟售票过程。这个方法使用了 `synchronized` 关键字来保证多线程安全。

然后我们定义了一个 `TicketSellerThread` 类来表示售票员线程，每个售票员线程都会不断调用 `TicketPool` 的 `sellTicket()` 方法来售票。在 `sellTicket()` 方法中，我们输出了售票员的名称来显示是哪个线程售出了票。

最后，在 `TicketSeller` 类中，我们创建了两个售票员线程，并启动它们。当程序运行时，两个售票员线程会不断地竞争售票，直到票池中没有票可以售出为止。

### 回答2：
以下是使用Java语言编写的一个程序，创建了两个线程来模拟售票的过程，同时在输出结果时会显示是哪个线程售出的票。

public class TicketSeller {
    private static int availableTickets = 10;

    public static void main(String[] args) {
        TicketSeller seller = new TicketSeller();

        // 创建两个线程来模拟售票过程
        Thread thread1 = new Thread(new Runnable() {
            @Override
            public void run() {
                seller.sellTickets("Thread 1");
            }
        });

        Thread thread2 = new Thread(new Runnable() {
            @Override
            public void run() {
                seller.sellTickets("Thread 2");
            }
        });

        // 启动两个线程
        thread1.start();
        thread2.start();
    }

    // 售票方法
    public synchronized void sellTickets(String threadName) {
        while (availableTickets > 0) {
            // 模拟票务处理过程
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            // 售票
            System.out.println(threadName + " 售出了第 " + availableTickets + " 张票");
            availableTickets--;
        }
    }
}

在上述程序中，创建了一个静态的 `availableTickets` 变量用于表示剩余的票数。`TicketSeller` 类中的 `sellTickets` 方法使用了 `synchronized` 关键字来实现线程同步，保证了多个线程访问 `sellTickets` 方法时的互斥性。

在 `main` 方法中，创建了两个线程 `thread1` 和 `thread2`，分别以 "Thread 1" 和 "Thread 2" 的名称作为参数调用 `sellTickets` 方法，模拟售票过程。

在 `sellTickets` 方法中，通过 `synchronized` 关键字保证了多个线程共享同一个 `availableTickets` 变量，并根据剩余票数打印出当前售出的票。

程序的输出结果类似于下面这样：

Thread 1 售出了第 10 张票
Thread 2 售出了第 9 张票
Thread 1 售出了第 8 张票
Thread 2 售出了第 7 张票
...

每一行输出都会显示是哪个线程售出的票。