java多线程龟兔赛跑（JAVA的程序设计，设计一个龟兔赛跑的线程类模拟参与赛跑）

本文目录

• JAVA的程序设计，设计一个龟兔赛跑的线程类模拟参与赛跑
• java龟兔赛跑求简单多线程
• JAVA龟兔赛跑问题
• 急求java龟兔赛跑
• java 用多线程模拟龟兔赛跑：
• 用JAVA多线程实现龟兔赛跑
• Java的龟兔赛跑多线程问题
• java模拟龟兔赛跑问题用多线程实现

JAVA的程序设计，设计一个龟兔赛跑的线程类模拟参与赛跑

感觉挺有趣的，试着写了个~

public static void main(String arg) {
new wugui().run();
new tuzi().run();
}

static class wugui {
final int sudu = 4;// 乌龟的速度是每秒4米
public static boolean hasEnd = false;// 是否已经跑到终点
public void run() {
new Thread() {
public void run() {
int distance = 0;
while (distance 《 100) {
try {
Thread.sleep(1000);
distance += sudu;
System.out.println(“小乌龟跑了“ + distance + “米“);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
hasEnd = true;
if (tuzi.hasEnd) {
System.out.println(“呜呜，差一点点就赢了~“);
} else {
System.out.println(“胜利是属于有准备的人的，你的自大害了你！-------乌龟赢了“);
}
}
}.start();
}
}

static class tuzi {
final int sudu = 5;// 兔子的速度是每秒5米
public static boolean hasEnd = false;// 是否已经跑到终点
public void run() {
new Thread() {
@Override
public void run() {
int distance = 0;// 跑了多少米
boolean hasXiuXi = false;// 是否休息过
while (distance 《 100) {
try {
Thread.sleep(1000);
distance += sudu;
System.out.println(“小兔子跑了“ + distance + “米“);
if (distance 》 50 && !hasXiuXi) {
System.out.println(“小兔子累了，决定休息一会儿~“);
Thread.sleep((long) (10000 * Math.random()));
System.out.println(“小兔子休息够了，又开始跑了，决一胜负吧！“);
hasXiuXi = true;
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
hasEnd = true;
if (wugui.hasEnd) {
System.out.println(“呜呜，早知道就不休息了~“);
} else {
System.out.println(“哇哈哈，你个战5渣也想赢我~~做梦去吧！！-------兔子赢了“);
}
}
}.start();
}
}

java龟兔赛跑求简单多线程

public class Competition {
private volatile static boolean gameOver = false;//用来标记是否有人到达终点，到达终点后游戏结束
//乌龟的实现方式
static class Tortoise implements Runnable{
private volatile int total = 0;//用来记录当前已经前行了多少距离
@Override
public void run() {
while(!gameOver){
int step = (int)(Math.random()*5+1);//产生1-5的随机数
total += step;
try {
Thread.sleep(200);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}

}
public int getTotal(){
return total;
}
}
//兔子的实现方式
static class Rabbit implements Runnable{
private volatile int total = 0;
@Override
public void run() {
while(!gameOver){
int step = (int)(Math.random()*5+1);
total += step;
try {
Thread.sleep(200);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
public int getTotal(){
return total;
}

}
/**
 * @param args
 */
public static void main(String args) {
// TODO Auto-generated method stub
final Tortoise tortoise = new Tortoise();
final Rabbit rabbit = new Rabbit();
new Thread(tortoise).start();
new Thread(rabbit).start();
//下面多起了一个线程，相当于比赛的时候的裁判员，他每隔一段时间就看一下是否有人到达终点，若有人到达则宣判该人获胜，游戏结束
new Thread(new Runnable(){

@Override
public void run() {
// TODO Auto-generated method stub
while(!gameOver){
int torLen = tortoise.getTotal();//获得乌龟前行的距离
int rabLen = rabbit.getTotal();//获得兔子前行的距离
System.out.println(“乌龟:“+torLen+“,兔子“+rabLen);
if(torLen 》= 100 && rabLen 《100){
System.out.println(“乌龟获胜!!!“);
gameOver = true;
}else if(rabLen 》= 100 && torLen 《100){
System.out.println(“兔子获胜!!!“);
gameOver = true;
}else if(rabLen 》=100 && torLen 》= 100){//这里有可能两人同时到达终点
System.out.println(“同时到达终点!!!“);
gameOver = true;
}
try {
Thread.sleep(210);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}

}).start();

}

JAVA龟兔赛跑问题

先让兔子进入阻塞状态，然后等乌龟跑完终点后唤醒兔子线程就行；下面是各个方法的配套使用（网上copy的，总结的很不错）1. sleep() 方法：sleep() 允许 指定以毫秒为单位的一段时间作为参数，它使得线程在指定的时间
内进入阻塞状态，不能得到CPU 时间，指定的时间一过，线程重新进入可执行状态。
　　典型地，sleep() 被用在等待某个资源就绪的情形：测试发现条件不满足后，让线程阻塞一段时间后
重新测试，直到条件满足为止。
　　2. suspend() 和 resume() 方法：两个方法配套使用，suspend()使得线程进入阻塞状态，并且不会
自动恢复，必须其对应的resume() 被调用，才能使得线程重新进入可执行状态。典型地，suspend() 和
resume() 被用在等待另一个线程产生的结果的情形：测试发现结果还没有产生后，让线程阻塞，另一个
线程产生了结果后，调用 resume() 使其恢复。
　　3. yield() 方法：yield() 使得线程放弃当前分得的 CPU 时间，但是不使线程阻塞，即线程仍处于
可执行状态，随时可能再次分得 CPU 时间。调用 yield() 的效果等价于调度程序认为该线程已执行了足
够的时间从而转到另一个线程。
　　4. wait() 和 notify() 方法：两个方法配套使用，wait() 使得线程进入阻塞状态，它有两种形式
，一种允许指定以毫秒为单位的一段时间作为参数，另一种没有参数，前者当对应的 notify() 被调用或
者超出指定时间时线程重新进入可执行状态，后者则必须对应的 notify() 被调用。

详情请见http://blog.csdn.net/small____fish/article/details/7726468

急求java龟兔赛跑

public class GuiTuSaiPao implements Runnable {
private String name;
private int length=0;

public GuiTuSaiPao(){}

public GuiTuSaiPao(String name){
this.name=name;
}

public void run(){
while(true){
//每次停500毫秒
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
//向前跑十米
length+=10;
System.out.println(name+“已跑了“+length+“米.“);
//到达终点
if(length》=100){
System.out.println(name+“,已经到达终点!“);
//结束赛跑,break
break;
}
}
}

public static void main(String args) {
GuiTuSaiPao wugui=new GuiTuSaiPao(“乌龟“);
GuiTuSaiPao tuzi=new GuiTuSaiPao(“兔子“);
Thread thread=new Thread(wugui);
Thread thread2=new Thread(tuzi);
//启动线程
thread.start();
thread2.start();
}
}

java 用多线程模拟龟兔赛跑：

public class TortoiseAndHareRace {
public static void main(String args) {
Runnable vs=new Race();
Thread hare=new Thread(vs,“Hare“);
Thread tortoise =new Thread(vs,“Tortoise“);
System.out.println(“Ready!GO!“);
hare.start();
tortoise.start();
}
}
class Race implements Runnable{
private static final int S=1000;
@Override
public void run() {
if(Thread.currentThread().getName().equals(“Hare“)){
int sHare=0;
while(sHare《=S){
sHare+=5;
if(sHare%20==0)
try {Thread.sleep(500);} catch (InterruptedException e) {e.printStackTrace();}
}
}else{
int sTortoise=0;
while(sTortoise《=S){
sTortoise++;
if(sTortoise%100==0)
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}

用JAVA多线程实现龟兔赛跑

程序如下：

/**
*
* GuiTuSaiPao.java
* @author Antonio
* 2009年9月2日20:16:33
* 实现Runnable接口中的run方法
*
*/
public class GuiTuSaiPao implements Runnable {
private String name;
private int length=0;

public GuiTuSaiPao(){}

public GuiTuSaiPao(String name){
this.name=name;
}

public void run(){
while(true){
//每次停500毫秒
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
//向前跑十米
length+=10;
System.out.println(name+“已跑了“+length+“米.“);
//到达终点
if(length》=100){
System.out.println(name+“,已经到达终点!“);
//结束赛跑,break
break;
}
}
}

public static void main(String args) {
GuiTuSaiPao wugui=new GuiTuSaiPao(“乌龟“);
GuiTuSaiPao tuzi=new GuiTuSaiPao(“兔子“);
Thread thread=new Thread(wugui);
Thread thread2=new Thread(tuzi);
//启动线程
thread.start();
thread2.start();

}

}

输出结果：（不一定每次都一样！）
乌龟已跑了10米.
兔子已跑了10米.
兔子已跑了20米.
乌龟已跑了20米.
乌龟已跑了30米.
兔子已跑了30米.
兔子已跑了40米.
乌龟已跑了40米.
兔子已跑了50米.
乌龟已跑了50米.
乌龟已跑了60米.
兔子已跑了60米.
乌龟已跑了70米.
兔子已跑了70米.
乌龟已跑了80米.
兔子已跑了80米.
兔子已跑了90米.
乌龟已跑了90米.
兔子已跑了100米.
兔子,已经到达终点!
乌龟已跑了100米.
乌龟,已经到达终点!

完全看rp，这就是线程！

给分吧，哈哈

Java的龟兔赛跑多线程问题

public class Competition {
private volatile static boolean gameOver = false;//用来标记是否有人到达终点，到达终点后游戏结束
//乌龟的实现方式
static class Tortoise implements Runnable{
private volatile int total = 0;//用来记录当前已经前行了多少距离
@Override
public void run() {
while(!gameOver){
int step = (int)(Math.random()*5+1);//产生1-5的随机数
total += step;
try {
Thread.sleep(200);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}

}
public int getTotal(){
return total;
}
}
//兔子的实现方式
static class Rabbit implements Runnable{
private volatile int total = 0;
@Override
public void run() {
while(!gameOver){
int step = (int)(Math.random()*5+1);
total += step;
try {
Thread.sleep(200);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
public int getTotal(){
return total;
}

}
/**
 * @param args
 */
public static void main(String args) {
// TODO Auto-generated method stub
final Tortoise tortoise = new Tortoise();
final Rabbit rabbit = new Rabbit();
new Thread(tortoise).start();
new Thread(rabbit).start();
//下面多起了一个线程，相当于比赛的时候的裁判员，他每隔一段时间就看一下是否有人到达终点，若有人到达则宣判该人获胜，游戏结束
new Thread(new Runnable(){

@Override
public void run() {
// TODO Auto-generated method stub
while(!gameOver){
int torLen = tortoise.getTotal();//获得乌龟前行的距离
int rabLen = rabbit.getTotal();//获得兔子前行的距离
System.out.println(“乌龟:“+torLen+“,兔子“+rabLen);
if(torLen 》= 100 && rabLen 《100){
System.out.println(“乌龟获胜!!!“);
gameOver = true;
}else if(rabLen 》= 100 && torLen 《100){
System.out.println(“兔子获胜!!!“);
gameOver = true;
}else if(rabLen 》=100 && torLen 》= 100){//这里有可能两人同时到达终点
System.out.println(“同时到达终点!!!“);
gameOver = true;
}
try {
Thread.sleep(210);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}

}).start();

}

java模拟龟兔赛跑问题用多线程实现

import java.util.Date;
public class Test extends Thread{ private int tortoise_walk = 0; // 乌龟已跑长度存放变量
private int rabbit_walk = 0; // 兔子已跑长度存放变量
private int finish = 1000; // 终点
private volatile boolean hasWinner = false;// 胜利者诞生 /**
*
* @ClassName: Tortoise_Run
* @Description: TODO(乌龟奔跑线程)
* @author guotingchao
* @date 2012-3-6 上午10:20:45
*
*/
class Tortoise_Run implements Runnable {
@Override
public void run() {
try {
while (!hasWinner) {
if (tortoise_walk % 100 == 0 && (tortoise_walk != 0||tortoise_walk》=finish)) { //乌龟每100米休息500毫秒
System.out.println(“乌龟休息中………………“);
Thread.sleep(500);
}
tortoise_walk++;
System.out.println(“乌龟已跑“+tortoise_walk+“米“);
}

} catch (InterruptedException e) {
e.printStackTrace();
}
}
} /**
*
* @ClassName: Rabbit_Run
* @Description: TODO(兔子奔跑线程)
* @date 2012-3-6 上午10:25:10
* @author guotingchao
*/
class Rabbit_Run implements Runnable {
@Override
public void run() {
try {
while (!hasWinner) {
if (rabbit_walk % 20 == 0 && (rabbit_walk != 0||rabbit_walk》=finish)) { //兔子每20米休息500毫秒
System.out.println(“兔子休息中………………“);
Thread.sleep(500);
}
rabbit_walk=rabbit_walk+5; //每秒跑5步
System.out.println(“兔子已跑“+rabbit_walk+“米“);
}

} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
@Override
public void run(){
new Thread(new Rabbit_Run()).start();
new Thread(new Tortoise_Run()).start();
}
/**
* @Title: main
* @Description: TODO(
* 赛程1000米，兔子跑5米，乌龟跑1米，兔子每20米休息500毫秒，乌龟每100米休息500毫秒。谁先到终点就结束程序
* ，并显示获胜方。)
* @param @param args
* @param @throws Exception 设定文件
* @author guotingchao
* @return void 返回类型
* @throws
*/
public static void main(String args) throws Exception {
long temp_actionTime=System.currentTimeMillis();
System.out.println(“比赛开始：“+new Date(temp_actionTime)+“毫秒“);
Test t=new Test();
new Thread(t).start();
while(true){
if(t.tortoise_walk》=t.finish||t.rabbit_walk》=t.finish){
t.hasWinner=true;
break;
}
}
String winnnerName=t.tortoise_walk》t.rabbit_walk?“乌龟“:“兔子“;
long temp_lastTime=System.currentTimeMillis();
System.out.println(winnnerName+“胜利“);
System.out.println(“比赛结束：“+new Date(temp_lastTime)+“毫秒“);
System.out.println(“所耗时间：“+(temp_lastTime-temp_actionTime)+“毫秒“);
System.out.println(“兔子=“+t.rabbit_walk+“ 乌龟=“+t.tortoise_walk);
}
}
//不知道兔子和乌龟的步长时间是否按每秒。 这里程序只考虑依次递增频率