1.龟兔赛跑：2000米 ； 2.兔子每 0.1 秒 5 米的速度，每跑20米休息1秒; 3.乌龟每 0.1 秒跑 2 米，不休息； 4.其中一个跑到终点后另一个不跑了！ （二）要求 1.创建一个Animal动物类，继承Thread，编写一个running抽象方法，重写run方法，把running方法在run方法里面调用。 2.创建Rabbit兔子类和Tortoise乌龟类，继承动物类 3.两个子类重写running方法 4.本题的第3个要求涉及到线程回调(Calltoback)。需要在动物类创建一个回调接口，创建一个回调对象。

这题目考察了多线程编程和面向对象的思想，是一道比较经典的Java面试题目。以下是一个可能的解题思路和代码实现：

Animal 类：

public abstract class Animal extends Thread {
    public Calltoback callback;

    public Animal(Calltoback callback) {
        this.callback = callback;
    }

    public abstract void running();

    @Override
    public void run() {
        super.run();
        boolean isRaceOver = false;
        while (!isRaceOver) {
            running();
            isRaceOver = callback.isRaceOver();
        }
    }
}

Rabbit 类：

public class Rabbit extends Animal {
    public Rabbit(Calltoback callback) {
        super(callback);
    }

    @Override
    public void running() {
        int move = 5; // 兔子每次移动的距离
        int rest = 20; // 兔子每跑完20米休息1秒
        int step = 0;
        while (step < 2000) {
            try {
                sleep(100); // 模拟兔子每 0.1 秒跑 5 米的速度
                step += move;
                if (step % rest == 0) {
                    sleep(1000); // 模拟兔子每跑完20米休息1秒
                }
                System.out.println("兔子跑了 " + step + " 米");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        callback.raceOver("兔子");
    }
}

Tortoise 类：

public class Tortoise extends Animal {
    public Tortoise(Calltoback callback) {
        super(callback);
    }

    @Override
    public void running() {
        int move = 2; // 乌龟每次移动的距离
        int step = 0;
        while (step < 2000) {
            try {
                sleep(100); // 模拟乌龟每 0.1 秒跑 2 米的速度
                step += move;
                System.out.println("乌龟跑了 " + step + " 米");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        callback.raceOver("乌龟");
    }
}

Calltoback 接口：

public interface Calltoback {
    void raceOver(String winner);
    boolean isRaceOver();
}

Race 类：

public class Race implements Calltoback {
    private Animal rabbit;
    private Animal tortoise;

    public Race() {
        rabbit = new Rabbit(this);
        tortoise = new Tortoise(this);
    }

    public void start() {
        System.out.println("龟兔赛跑开始！");
        rabbit.start();
        tortoise.start();
    }

    @Override
    public synchronized void raceOver(String winner) {
        System.out.println("比赛结束，胜利者是：" + winner);
        rabbit.interrupt();
        tortoise.interrupt();
    }

    @Override
    public synchronized boolean isRaceOver() {
        if (rabbit.isInterrupted() || tortoise.isInterrupted()) {
            return true;
        } else {
            return false;
        }
    }

    public static void main(String[] args) {
        Race race = new Race();
        race.start();
    }
}

在 Race 类中，我们创建了一个兔子和一个乌龟对象，并在 start 方法中启动它们的线程。在 raceOver 方法中，我们判断比赛是否结束，如果结束则打印胜利者的名字，并中断兔子和乌龟的线程。在 isRaceOver 方法中，我们判断兔子和乌龟的线程是否被中断，如果有一个被中断，则返回 true 表示比赛结束。

以上是一种可能的解题思路和代码实现，供参考。