JAVA程序设计，求一个龟兔赛跑的多线程源码？要有注释

电玩 发表于 2013-5-5 09:22
/*
设计龟兔赛跑游戏，赛程为10步，每经过一秒，乌龟会前进一步，兔子则可能前进两步或者睡觉。
*/

注释很好！！！

/*
设计龟兔赛跑游戏，赛程为10步，每经过一秒，乌龟会前进一步，兔子则可能前进两步或者睡觉。
*/
public class  TortoiseAndHare  //龟兔赛跑
{
        public static void main(String[] args)
        {
                Tortoise tortoise=new Tortoise(10); //乌龟赛程为10步
                Hare hare=new Hare(10);  //兔子赛程为10步
               
                Thread tortoiseThread=new Thread(tortoise); //乌龟线程开启
                Thread hareThread=new Thread(hare);//兔子线程开启

tortoiseThread.start();//各就各位，预备开始。。。。
hareThread.start();     //各就各位，预备开始。。。。
        }
}
class Tortoise implements Runnable   //定义龟类
{
        private int totalStep;  //总步数
        private int step;       //一步

        public Tortoise(int totalStep)  //构造函数
                {
        this.totalStep=totalStep;
        }

        public void run(){   //定义龟类 跑步方法
        try
        {
                while (step<totalStep)  //当赛程未完时
                {
                        Thread.sleep(1000);   //1000是一秒 ，休息一秒
                        step++;               //再跑一步
            System.out.println("乌龟跑了"+step+"步.....");  //打印当前结果
                }
               

        }
        catch (InterruptedException e)  //抛异常
        {
                throw new RuntimeException(e);
        }
        if (step==totalStep)
        {
                System.out.println("乌龟已经跑完了比赛路程!");
        }
       
        }
}
class Hare implements Runnable //定义兔子类
{
        private boolean[] flags={true,false};//设置标志，兔子是否停下休息
    private int totalStep;  //总步数
        private int step;       //一步

        public Hare(int totalStep)  //兔子的构造函数
                {
        this.totalStep=totalStep;
        }

        public void run(){   //定义兔子类 跑步方法
        try
        {
                while (step<totalStep)  //当赛程未完时
                {
                        Thread.sleep(1000);   //1000是一秒 ，休息一秒
                        boolean isHareSleep=flags[(int)(Math.random()*10)%2];//随机判定兔子是否要休息
                        if (isHareSleep)//兔子要睡觉
                        {
                                System.out.println("兔子睡着了 zzzzzzzz");
                        }else{
                        step=step+2;               //再跑两步
                        System.out.println("兔子跑了"+step+"步.....");  //打印当前结果
                        }
                         

                }
        }
        catch (InterruptedException e)  //抛异常
        {
                throw new RuntimeException(e);
        }
        if (step==totalStep)
        {
                System.out.println("兔子跑完了比赛路程!");
        }
        }
}
/* 程序运行的结果之一
乌龟跑了1步.....
兔子跑了2步.....
乌龟跑了2步.....
兔子睡着了 zzzzzzzz
乌龟跑了3步.....
兔子跑了4步.....
乌龟跑了4步.....
兔子跑了6步.....
乌龟跑了5步.....
兔子睡着了 zzzzzzzz
乌龟跑了6步.....
兔子跑了8步.....
乌龟跑了7步.....
兔子跑了10步.....
兔子跑完了比赛路程!
乌龟跑了8步.....
乌龟跑了9步.....
乌龟跑了10步.....
乌龟已经跑完了比赛路程!
*/

如果仍有问题，请继续追问，如果问题已解决，请将分类改为已解决，谢谢

/**
　　*　一段模拟龟兔赛跑的多线程程序。
　　*　兔子比乌龟快5倍，但休息的时间长10倍。
　　*/
public class  T
{
   public static void main(String args[])
   {
   TortoiseRace a =new TortoiseRace();
   Thread runner1 =new Thread(a);
   RabbitRace b=new RabbitRace();
   Thread runner2=new Thread(b);
   runner1.start();
   runner2.start();
      while(ready<2)
      {
         try
           {
            Thread.sleep(1);   //乌龟休息一秒
           }
         catch(InterruptedException e)
           {
            e.printStackTrace();
            }
       }
     synchronized(lock)
     {
      lock.notifyAll();
      }
   }
   static Object lock=new Object();
   static int ready=0;
}

class TortoiseRace implements Runnable
{
   public void run()
   {
     synchronized (T.lock)
     {
     T.ready++;
       try
       {
       T.lock.wait();
       }
       catch(InterruptedException e1)
       {
        e1.printStackTrace();
       }
     }
     int TortoiseDistance=0;
     for(int i=0;TortoiseDistance<=1000;i++)
     {
      TortoiseDistance++;
       System.out.println("乌龟跑了1米!");
         try
         {
           Thread.sleep(1);
         }
         catch(InterruptedException e)
         {
         }
     }
    System.out.println("乌龟已经跑完了比赛路程!");
   }
}

class RabbitRace implements Runnable
{
  public void run()
  {
  T.ready++;
    synchronized(T.lock)
    {
      try
      {
      T.lock.wait();
      }
      catch(InterruptedException e1)
      {
              e1.printStackTrace();
      }
    }
    int RabbitDistance=0;
    for(int j=0;RabbitDistance<=1000;j++)
    {
            RabbitDistance+=5;
            System.out.println("兔子跑了5米!");
            try
            {
                    Thread.sleep(10);//兔子休息十秒
            }
            catch(InterruptedException e)
            {
            }
    }
    System.out.println("兔子跑完了比赛路程!");
  }
}