Java多线程--模拟龟兔赛跑

要求：

兔子：每100毫秒跑2米，跑了80米后，睡100毫秒

乌龟：每100毫秒跑1米

（1）累加思想，使用for循环控制兔子以及乌龟的跑步速度和路程

（2）在Thread类有Thread.sleep()方法，来控制兔子的睡眠时间，可以尝试使用不同的睡眠时间来让乌龟赢还是兔子赢

 （3）使用System.currentTimeMillis()得到当前系统时间，并在线程执行完成后获得当前系统时间，用后面的时间减去前面的时间。得到乌龟和兔子跑完100米的时间

（4）在测试类中比较二者的时间，得到谁输谁赢

实现Runnable接口

多线程类实现Runnable接口后，还是需要Thread类下的start()方法来启动线程

package cn.sz.gl.no6;

public class MyRunnable implements Runnable {

    @Override
    public void run() {
        System.out.println("我的线程...");
    }

}

启动线程：

package cn.sz.gl.no6;

public class Test {

    public static void main(String[] args) {
        MyRunnable mra = new MyRunnable();
        MyRunnable mrb = new MyRunnable();
        MyRunnable mrc = new MyRunnable();
        MyRunnable mrd = new MyRunnable();
        MyRunnable mre = new MyRunnable();
        
        new Thread(mra).start();
        new Thread(mrb).start();
        new Thread(mrc).start();
        new Thread(mrd).start();
        new Thread(mre).start();
        
    }
}

 

采用实现Runnable接口方式：

      （1）优点：线程类只是实现了Runable接口，还可以继承其他的类。在这种方式下，可以多个线程共享同一个目标对象，所以非常适合多个相同线程来处理同一份资源的情况，从而可以将CPU代码和数据分开，形成清晰的模型，较好地体现了面向对象的思想。 　

      （2）缺点：编程稍微复杂，如果需要访问当前线程，必须使用Thread.currentThread()方法。  

 1.创建RabbitThread线程

实现：  兔子：每100毫秒跑2米，跑了80米后，睡10秒

RabbitThread.java文件代码：

/**
* 兔子线程
*/
public class RabbitThread implements  Runnable {
    private long time;  //跑100米的耗时

    public long getTime() {
        return time;
    }

    @Override
    public void run() {
        // 记录程序开始执行的时间
        long start = System.currentTimeMillis();

// 模拟兔子跑步的过程，每次循环增加2米，直到100米
        for (int i = 0; i < 100; i += 2) {
            // 当跑到80米时，兔子休息1秒
            if (i == 80) { // 跑到80米
                try {
                    // 打印兔子睡觉的信息
                    System.out.println("兔子睡1s");
                    // 线程暂停1秒，模拟兔子睡觉
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    // 如果线程被中断，打印异常信息
                    e.printStackTrace();
                }
            }
            // 每次循环后暂停100毫秒，模拟跑步过程
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                // 如果线程被中断，打印异常信息
                e.printStackTrace();
            }
            // 打印兔子当前跑完的距离
            System.out.println("兔子跑完" + i + "米");
        }

// 计算程序执行的总时间
        time = System.currentTimeMillis() - start;

    }
}

2.创建 TortoiseThread线程

实现  乌龟：每100毫秒跑1米

TortoiseThread.java文件代码：

/**
* 乌龟线程
*/
public class TortoiseThread  implements  Runnable{

    //声明一个私有变量time，用于记录跑100米的耗时
    private long time;

    /**
     * 获取跑100米的耗时
     * @return 跑100米的耗时，单位为毫秒
     */
    public long getTime() {
        return time;
    }

    //重写run方法，模拟乌龟跑步的过程
    @Override
    public void run() {
        //记录开始时间
        long start = System.currentTimeMillis();
        //循环100次，每次代表跑1米
        for (int i = 0; i <100 ; i++) {
            //模拟跑1米所需的时间，这里使用休眠线程的方式
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                //如果线程被中断，则打印异常信息
                e.printStackTrace();
            }
            //打印乌龟跑步的进度
            System.out.println("乌龟跑完"+i+"米");
        }

        //计算并记录跑100米的总耗时
        time = System.currentTimeMillis() - start;
    }
}

 3.创建测试类

Test.java代码文件：

public class Test3 {
    public static void main(String[] args) throws InterruptedException {
        //宣布比赛开始
        System.out.println("龟兔赛跑开始.....");

//创建兔子线程对象
        RabbitThread rabbitThread = new RabbitThread();

//创建乌龟线程对象
        TortoiseThread tortoiseThread = new TortoiseThread();

//将兔子线程对象封装到Thread对象中
        Thread  rabbit = new Thread(rabbitThread);

//将乌龟线程对象封装到Thread对象中
        Thread  tortoise = new Thread(tortoiseThread);

//启动兔子线程
        rabbit.start();

//启动乌龟线程
        tortoise.start();

//统计比赛结果  main线程执行,   一定要等兔子线程, 乌龟线程执行完成才统计
//Thread对象.join()
        rabbit.join();
        tortoise.join();

//比较兔子和乌龟的比赛时间，以确定比赛结果
        if(rabbitThread.getTime() < tortoiseThread.getTime()){
            //如果兔子的时间小于乌龟的时间，兔子赢得比赛
            System.out.println("兔子赢得比赛");
        }else if(rabbitThread.getTime() > tortoiseThread.getTime()){
            //如果兔子的时间大于乌龟的时间，乌龟赢得比赛
            System.out.println("乌龟赢得比赛");
        }else{
            //如果兔子和乌龟的时间相等，比赛结果为平局
            System.out.println("平局");
        }
    }
}

 运行结果：