JavaSE之多线程（龟兔赛跑）

准备

思绪

想要建立一个龟兔赛跑的方法，我们首先要想到的就是多线程，创建一个进程中出现两个线程，一只兔子，一只乌龟。

1. 乌龟跑的慢，但是不会停下；兔子跑的快，但是会休息；
2. 两个都在同一出发点，走同样远的距离；
3. 如果到最后，有一个到达终点，则游戏终结。

线程解读

Thead类

通过Thread 类创建线程，创建子类，继承自Thread ，并且重写run方法。

class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println("Hello thread");
    }
}
1
2
3
4
5
6

之后实例化Thread，创建实例对象

 Thread thread = new MyThread();
1

start 方法启动线程

thread.start();
1

这样在创建main主方法中 将线程启动就好了

public static void main(String[] args){
	Thread thread = new MyThread();
	thread.start();
} 
1
2
3
4

thread.sleep：使线程短暂休眠

Runnable接口

通过使用Runnable接口创建进程对象，实现Runnable接口

public class Race implements Runnable {
    @Override
    public void run() {
      	 System.out.println("Hello Runnable");
    }
}
1
2
3
4
5
6

创建main主方法

public static void main(String[] args) {
	Race race = new Race();
	
	//写法1
	Thread thread = new Thread(race);
	thread.start();
  
	//写法2
	new Thread (race,"name").start();
}
1
2
3
4
5
6
7
8
9
10

Thread 的常见构造方法

Thread()：创建线程对象
Thread(Runnable target)：使用 Runnable 对象创建线程对象
Thread(String name)：创建线程对象，并命名
Thread(Runnable target, String name)：使用 Runnable 对象创建线程对象，并命名

实施过程

实现龟兔赛跑，首先在重写的run方法中建立一个赛道，计算距离

public class Race implements Runnable {
	for(i=0,i==100;i++){
		// xx跑了多少步
		System.out.println(Thread.currentThread().getName()+"跑了"+i+ "步"）
	}
}
1
2
3
4
5
6

Thread.currentThread表示当前代码段正在被哪个线程调用的相关信息。

创建main主方法，new两个对象：兔子和乌龟

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

	new Thread(race,"兔子"）.start();
	new Thread(race,"乌龟"）.start();
}
1
2
3
4
5
6
7

判定比赛结束

// 定义一个单例的静态值
private static String winner;

// 创建一个游戏结束的判断方法
public boolean gameOver(step){
	if(winner!=null){
		return true;
	}else if(step>=100){
		winner = Thread.currThread().getName();
		System.out.println(winner + "获胜");
		return true;
	}
	return false;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

在for循环中追加一个标记flag，如果一方胜利则跳出循环

boolean flag = gameOver(i）;
if (flag){
	break;
}
1
2
3
4

追加兔子睡觉的sleep机能

 if ("兔子".equals(Thread.currentThread().getName()) && i % 10 == 0) {
	 try {
	     Thread.sleep(10);
	 } catch (InterruptedException e) {
	     e.printStackTrace();
	 }
 }
1
2
3
4
5
6
7

整合代码

package com.stu;

/**
 * 多线程的龟兔赛跑
 * 通过 Runnable 接口
 */
public class Race implements Runnable {

    // 定义一个胜利者对象
    private static String winner;

    public static void main(String[] args) {
        Race race = new Race();
        // 开启线程
        new Thread(race, "兔子").start();
        new Thread(race, "乌龟").start();
    }

    // 重写一个run方法
    @Override
    public void run() {
        for (int i = 0; i < 101; i++) {

            //flag 比赛结果
            boolean flag = gameOver(i);

            // 比赛结束 跳出循环
            if (flag) {
                break;
            }

            // 判断如过是兔子就会偷懒睡觉
            if ("兔子".equals(Thread.currentThread().getName()) && i % 10 == 0) {
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

            System.out.println(Thread.currentThread().getName() + "-->跑了" + i + "步");
        }
    }

    // 判断游戏是否完成
    private boolean gameOver(int steps) {
        //判断是否出现胜利者
        if (winner != null) {
            return true;
        } else if (steps >= 100) {
            winner = Thread.currentThread().getName();
            System.out.println("winner is " + winner);
            return true;
        }
        return false;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58