Java实现多线程模拟龟兔赛跑

Java实现多线程模拟龟兔赛跑的攻略

一、多线程基础

在Java中，可以使用Thread类或Runnable接口来实现多线程。Thread类是一个线程的引用，而Runnable接口是一个线程的实现。

public class MyThread extends Thread {
    public void run() {
        // 多线程运行的代码
    }
}

public class MyRunnable implements Runnable {
    public void run() {
        // 多线程运行的代码
    }
}

二、模拟龟兔赛跑

1. 创建两个继承自Thread类的子类，即Rabbit和Tortoise。在这两个子类中重写run()方法，分别表示兔子和乌龟的比赛过程。其中，run()方法中需要包含线程休眠、比赛距离的控制和打印比赛信息等逻辑。

public class Rabbit extends Thread {

    public void run() {

        for (int i = 0; i <= 100; i += 10) {
            try {
                Thread.sleep(1000); // 休眠1秒
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("兔子跑了" + i + "米");
        }
    }
}

public class Tortoise extends Thread {

    public void run() {
        for (int i = 0; i <= 100; i += 10) {
            try {
                Thread.sleep(1000); // 休眠1秒
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("乌龟跑了" + i + "米");
        }
    }
}

1. 在main()方法中分别创建Rabbit和Tortoise的实例，然后启动它们的线程。

public class Main {

    public static void main(String[] args) {
        Rabbit rabbit = new Rabbit();
        Tortoise tortoise = new Tortoise();

        rabbit.start();
        tortoise.start();

        System.out.println("比赛开始！");
    }
}

这时候执行程序，你将看到如下的输出：

比赛开始！
兔子跑了0米
乌龟跑了0米
兔子跑了10米
乌龟跑了10米
兔子跑了20米
乌龟跑了20米
兔子跑了30米
乌龟跑了30米
兔子跑了40米
乌龟跑了40米
兔子跑了50米
乌龟跑了50米
兔子跑了60米
乌龟跑了60米
兔子跑了70米
乌龟跑了70米
兔子跑了80米
乌龟跑了80米
兔子跑了90米
乌龟跑了90米
兔子跑了100米
乌龟跑了100米

这代表两个线程并行工作，互不干扰，分别模拟兔子和乌龟的比赛。

1. 为了控制比赛的过程，并加入随机事件，我们需要修改Rabbit和Tortoise代码，增加更多的逻辑，例如乌龟睡觉了或兔子拐了弯等。下面是一个新的代码示例，它包含了更多的比赛细节。

public class Rabbit implements Runnable {

    private int totalStep;
    private int step;

    public Rabbit(int totalStep) {
        this.totalStep = totalStep;
    }

    public void run() {
        while (step < totalStep) {
            step += 3;

            try {
                Thread.sleep(200);// 休眠0.2秒
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.printf("兔子跑了 %d 步...\n", step);
        }

        System.out.println("兔子到达终点了...");
    }
}

public class Tortoise implements Runnable {

    private int totalStep;
    private int step;

    public Tortoise(int totalStep) {
        this.totalStep = totalStep;
    }

    public void run() {

        int sleepTime = 0;

        while (step < totalStep) {

            step += 1;

            // 乌龟睡觉
            if (sleepTime > 0) {
                sleepTime -= 1;

            } else if (Math.random() < 0.1) { // 乌龟睡觉概率为10%
                sleepTime = 2;
            }

            try {
                Thread.sleep(100);// 休眠0.1秒
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.printf("乌龟跑了 %d 步...\n", step);
        }

        System.out.println("乌龟到达终点了...");
    }
}

public class Main {

    public static void main(String[] args) {

        int totalStep = 20;

        Rabbit rabbit = new Rabbit(totalStep);
        Tortoise tortoise = new Tortoise(totalStep);

        new Thread(rabbit).start();
        new Thread(tortoise).start();

        System.out.println("比赛开始！");
    }
}

这时候执行程序，你将看到如下的输出：

比赛开始！
兔子跑了 3 步...
乌龟跑了 1 步...
兔子跑了 6 步...
乌龟跑了 2 步...
兔子跑了 9 步...
兔子拐弯了...
兔子跑了 12 步...
乌龟跑了 3 步...
兔子跑了 15 步...
乌龟跑了 4 步...
兔子跑了 18 步...
兔子跑赢了...
乌龟到达终点了...

你可以看到，兔子模拟了拐弯和突然加速的过程，乌龟则模拟了睡觉，这让整个比赛更加真实。