Java从入门到放弃26—线程的三种创建方式之实现Runnable接口

01 Runnable接口

Runnable 接口应该由那些打算通过某一线程执行其实例的类来实现。类必须定义一个称为 run 的无参数方法。Runnable 为非 Thread 子类的类提供了一种激活方式。通过实例化某个 Thread 实例并将自身作为运行目标，就可以运行实现 Runnable 的类而无需创建 Thread 的子类。大多数情况下，如果只想重写 run() 方法，而不重写其他 Thread 方法，那么应使用 Runnable 接口。

接口中的方法

Runnable接口中仅包含唯一一个抽象方法，因此它是一个函数式接口（Functional Interface）。可以通过Lambda表达式简化表达。

方法摘要
`void`	`run()` 使用实现接口 `Runnable` 的对象创建一个线程时，启动该线程将导致在独立执行的线程中调用对象的 `run` 方法。

02 创建线程

通过实现Runnable接口创建线程的具体步骤：

step1：实现runable接口
step2：创建runable接口实现类
step3：启动线程。需要创建一个线程Thread对象，然后把Runable接口的实现类的实例放入构造参数里，调用start方法启动。

代码示例

public class RunableTest implements  Runnable {

    @Override
    public void run() {
        System.out.println("线程执行体");
    }

    public static void main(String[] args) {
        //创建runable接口实现类对象
        RunableTest runableTest = new RunableTest();
        //创建Thread对象，传入runable接口实现类对象
        Thread thread = new Thread(runableTest);
        //启动线程
        thread.start();
        System.out.println("线程正在启动");
        for (int i = 0; i < 100; i++) {
            System.out.println("主线程执行体");
        }
    }
}

03 案例

案例1：抢票

public class RunableTest2 implements Runnable{
    //定义票数
    private int ticketNum=10;

    @Override
    public void run() {
        try {
            test();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    private void test() throws InterruptedException {

        while (true){
            if (ticketNum<=0){
                break;
            }
            //加入休眠，放大问题发生性
            Thread.currentThread().sleep(1000);
            //抢票
            System.out.println(Thread.currentThread().getName()+"抢到了第"+(ticketNum--)+"张票");

            }
        }

    public static void main(String[] args) {
        //创建实现Runnable接口的实例
        RunableTest2 runableTest2 = new RunableTest2();

        //创建三个线程同步执行同一实例中run方法 模拟三人同抢一张票
        Thread threadA = new Thread(runableTest2, "A");
        Thread threadB = new Thread(runableTest2, "B");
        Thread threadC = new Thread(runableTest2, "C");
        //开启进程
        threadA.start();
        threadB.start();
        threadC.start();
    }
}

运行结果：由于多个线程同时操作一个对象,出现了数据紊乱的现象，本代码还未解决并发问题，因此出现了剩余票数

案例2：龟兔赛跑

public class Race implements Runnable{
    private static String winner;//冠军只有一个，因此用static修饰

    @Override
    public void run() {
        //定义一个全长为100步的赛道
        for (int Step = 1; Step <= 100; Step++) {

            System.out.println(Thread.currentThread().getName()+"跑了"+Step+"步");
            //兔子跑的太快，让兔子每50步休眠10ms
            if (Thread.currentThread().getName().equals("兔子")&&Step%50==0){
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            //判断比赛是否结束
            boolean flag = gameOver(Step);
            if (flag){
                break;
            }

        }
    }
//判断比赛是否结束
    private boolean gameOver(int step){
        if (winner!=null){//如果存在胜利者
            return true;
        }
        if (step==100){//如果跑完了全程
            winner=Thread.currentThread().getName();
            System.out.println("Game Over");
            System.out.println("Winner is "+winner);
            return true;
        }
        return false;
    }

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


        Thread thread1 = new Thread(race, "兔子");
        Thread thread2 = new Thread(race, "乌龟");

        thread1.start();
        thread2.start();
    }
}