java多线程习题:龟兔赛跑与素数计算

（一）龟兔赛跑

龟兔赛跑：20米
要求：

1. 兔子每秒0.5米的速度，每跑2米休息10秒，

2. 乌龟每秒跑0.1米，不休息

3. 其中一个跑到终点后另一个不跑了！

设计思路：

1. 创建一个Animal动物类，继承Thread，编写一个running抽象方法，重写run方法，把running方法在run方法里面调用。

2. 创建Rabbit兔子类和Tortoise乌龟类，继承动物类

3. 两个子类重写running方法

4. 本题的第3个要求涉及到线程回调。需要在动物类创建一个回调接口，创建一个回调对象

Animal

package com.thread8;

public abstract class Animal extends Thread{

    public double length=20;//比赛的长度

    public abstract void runing();//抽象方法需要子类实现

    //在父类重写run方法，在子类只要重写running方法就可以了
    @Override
    public void run() {
        super.run();
        while (length>0) {
            runing();
        }
    }

    //在需要回调数据的地方（两个子类需要），声明一个接口
    public static interface Calltoback{
        public void win();
    }

    //2.创建接口对象
    public Calltoback calltoback;

}

Rabbit

package com.thread8;

public class Rabbit extends Animal {

    public Rabbit() {
        setName("兔子");// Thread的方法，给线程赋值名字
    }

    // 重写running方法，编写兔子的奔跑操作
    @Override
    public void runing() {
        // 跑的距离
        double dis = 0.5;
        length -= dis;//跑完后距离减少
        if (length <= 0) {
            length = 0;
            System.out.println("兔子获得了胜利");
            //给回调对象赋值，让乌龟不要再跑了
            if (calltoback != null) {
                calltoback.win();
            }
        }
        System.out.println("兔子跑了" + dis + "米，距离终点还有" + (int)length + "米");

        if (length % 2 == 0) {// 两米休息一次
            try {
                sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

Tortoise

package com.thread8;

public class Tortoise extends Animal {

    public Tortoise() {
        setName("乌龟");// Thread的方法，给线程赋值名字
    }

    // 重写running方法，编写乌龟的奔跑操作
    @Override
    public void runing() {
        // 跑的距离
        double dis = 0.1;
        length -= dis;
        if (length <= 0) {
            length = 0;
            System.out.println("乌龟获得了胜利");
            // 让兔子不要在跑了
            if (calltoback != null) {
                calltoback.win();
            }
        }
        System.out.println("乌龟跑了" + dis + "米，距离终点还有" + (int) length + "米");
        try {
            sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

package com.thread8;

public class MainClass {
    /**
     * 龟兔赛跑：20米
     * */
    public static void main(String[] args) {
        //实例化乌龟和兔子
        Tortoise tortoise = new Tortoise();
        Rabbit rabbit = new Rabbit();
        //回调方法的使用，谁先调用calltoback方法，另一个就不跑了
        LetOneStop letOneStop1 = new LetOneStop(tortoise);
        rabbit.calltoback = letOneStop1;//让兔子的回调方法里面存在乌龟对象的值，可以把乌龟stop
        LetOneStop letOneStop2 = new LetOneStop(rabbit);
        tortoise.calltoback = letOneStop2;//让乌龟的回调方法里面存在兔子对象的值，可以把兔子stop
        //开始跑
        tortoise.start();
        rabbit.start();
    }
 }

（二）

编写一个有两个线程的程序，第一个线程用来计算2～100000之间的素数的个数，第二个线程用来计算100000～200000之间的素数的个数，最后输出结果。

package com.thread14;

class Thread1 implements Runnable {
    @Override
    public void run() {
// TODO Auto-generated method stub
        int j;
        for (int i = 2; i <= 100000; i++) {
            j = 2;
            for (; j <= Math.sqrt(i); j++) {
                if (i % j == 0) {
                    break;
                }
            }
            if (j > Math.sqrt(i))
                System.err.println(i);
        }
    }
}
class Thread2 implements Runnable {
    @Override
    public void run() {
// TODO Auto-generated method stub
        int j;
        for (int i = 100001; i <= 200000; i++) {
            j = 2;
            for (; j <= Math.sqrt(i); j++) {
                if (i % j == 0) {
                    break;
                }
            }
            if (j > Math.sqrt(i))
                System.err.println(i);
        }
    }
}
public class TwoThreadForPrime {
    public static void main(String[] args) {
        Thread t1 = new Thread(new Thread1());
        Thread t2 = new Thread(new Thread2());
        t1.start();
        t2.start();
    }
}