java设置生成计算机和搬运计算机类,生产一台搬走一台,如果没有等待生成,如果生成等待搬运,计算2分钟生成了多少台计算机

好的，以下是一个简单的 Java 代码示例，包含了 `ComputerProducer` 和 `ComputerMover` 类，实现了生产和搬运计算机的功能，并模拟了 2 分钟内生产的计算机数量：

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

public class Main {
    public static void main(String[] args) throws InterruptedException {
        // 创建一个队列来存储计算机
        Queue<Computer> queue = new LinkedList<>();

        // 创建一个计算机生产者对象和一个计算机搬运者对象
        ComputerProducer producer = new ComputerProducer(queue);
        ComputerMover mover = new ComputerMover(queue);

        // 启动这两个线程
        producer.start();
        mover.start();

        // 等待 2 分钟
        Thread.sleep(2 * 60 * 1000);

        // 停止这两个线程
        producer.stopRunning();
        mover.stopRunning();

        // 统计生产和搬运的计算机数量
        int produced = producer.getProducedCount();
        int moved = mover.getMovedCount();

        // 输出结果
        System.out.println("在 2 分钟内，生产了 " + produced + " 台计算机，搬运了 " + moved + " 台计算机。");
    }
}

// 计算机类
class Computer {
    // 计算机序列号
    private int sn;

    public Computer(int sn) {
        this.sn = sn;
    }

    public int getSn() {
        return sn;
    }
}

// 计算机生产者类
class ComputerProducer extends Thread {
    // 存储计算机的队列
    private Queue<Computer> queue;
    // 生产的计算机数量
    private int producedCount;
    // 是否继续运行
    private boolean running = true;

    public ComputerProducer(Queue<Computer> queue) {
        this.queue = queue;
    }

    public synchronized void stopRunning() {
        running = false;
    }

    public synchronized int getProducedCount() {
        return producedCount;
    }

    @Override
    public void run() {
        // 计算机序列号
        int sn = 0;
        while (running) {
            // 生产一台计算机
            Computer computer = new Computer(sn++);
            System.out.println("生产了一台计算机，序列号为 " + computer.getSn());
            synchronized (queue) {
                // 如果队列已满，等待搬运
                while (queue.size() == 10) {
                    try {
                        queue.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                // 将计算机放入队列中
                queue.offer(computer);
                // 唤醒等待的搬运者线程
                queue.notifyAll();
            }
            producedCount++;
        }
    }
}

// 计算机搬运者类
class ComputerMover extends Thread {
    // 存储计算机的队列
    private Queue<Computer> queue;
    // 搬运的计算机数量
    private int movedCount;
    // 是否继续运行
    private boolean running = true;

    public ComputerMover(Queue<Computer> queue) {
        this.queue = queue;
    }

    public synchronized void stopRunning() {
        running = false;
    }

    public synchronized int getMovedCount() {
        return movedCount;
    }

    @Override
    public void run() {
        while (running) {
            synchronized (queue) {
                // 如果队列为空，等待生产
                while (queue.isEmpty()) {
                    try {
                        queue.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                // 搬运一台计算机
                Computer computer = queue.poll();
                System.out.println("搬运了一台计算机，序列号为 " + computer.getSn());
                // 唤醒等待的生产者线程
                queue.notifyAll();
            }
            movedCount++;
        }
    }
}

在这个示例中，我们定义了一个 `Computer` 类，表示计算机对象，具有一个序列号属性 `sn`。然后定义了一个 `ComputerProducer` 类，表示计算机生产者对象，具有一个存储计算机的队列 `queue`，一个生产的计算机数量 `producedCount` 和一个是否继续运行的标志 `running`。在 `run` 方法中，我们使用一个 while 循环来不断生产计算机。如果队列已满，使用 `wait` 方法等待搬运者线程将计算机搬走；否则将计算机放入队列中，使用 `notifyAll` 方法唤醒等待的搬运者线程。最后，在生产计算机时将 `producedCount` 加 1。

然后定义了一个 `ComputerMover` 类，表示计算机搬运者对象，具有一个存储计算机的队列 `queue`，一个搬运的计算机数量 `movedCount` 和一个是否继续运行的标志 `running`。在 `run` 方法中，我们使用一个 while 循环来不断搬运计算机。如果队列为空，使用 `wait` 方法等待生产者线程生产计算机；否则从队列中取出一台计算机，使用 `notifyAll` 方法唤醒等待的生产者线程。最后，在搬运计算机时将 `movedCount` 加 1。

在 `Main` 类中，我们创建了一个队列来存储计算机，创建了一个计算机生产者对象和一个计算机搬运者对象，并启动这两个线程。然后使用 `Thread.sleep` 方法等待 2 分钟，停止这两个线程，并统计生产和搬运的计算机数量。最后输出结果。