【Java】线程基本使用——实现 Runnable接口

1. 实现 Runnable 接口

• 说明

1. java是单继承的，在某些情况下一个类可能已经继承了某个父类，这时在用继承Thread类方法来创建线程显然不可能了。
2. java设计者们提供了另外一个方式创建线程，就是通过实现Runnable接口来创建线程

• 应用案例
  请编写程序，该程序可以每隔1秒。在控制台输出“你好，兮动人”，当输出10次后，自动退出。
  使用实现Runnable接口的方式实现。

public class Thread02 {
    public static void main(String[] args) {
        Dog dog = new Dog();
        //dog.start(); //这里不能调用 start 方法
        //创建了 Thread 对象，把 dog 对象(实现了 Runnable )，放入了 Thread
        Thread thread = new Thread(dog);
        thread.start();
    }
}



class Dog implements Runnable { //通过实现Runnable接口来实现

    int count =  0;

    @Override
    public void run() { //普通方法
        while (true) {
            System.out.println("你好，兮动人-" + (++count) + Thread.currentThread().getName());

            //休眠1秒
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if (count == 10) {
                break;
            }
        }
    }
}

• 这里底层使用了设计模式【代理模式】=> 代码模拟实现Runnable接口 开发线程的机制。

public class Thread02 {
    public static void main(String[] args) {

        Tiger tiger = new Tiger();
        ThreadProxy threadProxy = new ThreadProxy(tiger);
        threadProxy.start();
    }
}

class Animal {}

class Tiger extends Animal implements Runnable {

    @Override
    public void run() {
        System.out.println("老虎...");
    }
}

//线程代理类，模拟了一个极简的Thread类
class ThreadProxy implements Runnable { //可以把 Proxy 类当做 Thread

    private Runnable target = null; // 属性类型 是 Runnable

    @Override
    public void run() {
        if (target != null) {
            target.run();//动态绑定(运行类型是Tiger)
        }
    }

    public ThreadProxy(Runnable target) {
        this.target = target;
    }

    public void start() {
        start0();//这个方法是真正实现多线程的方法
    }

    public void start0() {
        run();
    }
}

2. 线程使用应用案例–多线程执行

• 请编写一个程序，创建两个线程，一个线程每隔1秒输出“hello,world”，输出10次，退出，另一个线程每隔1秒输出“hi”，输出5次退出。

public class Thread03 {
    public static void main(String[] args) {
        T1 t1 = new T1();
        T2 t2 = new T2();
        Thread thread1 = new Thread(t1);
        thread1.start();
        Thread thread2 = new Thread(t2);
        thread2.start();
    }
}

class T1 implements Runnable {

    int count = 0;

    @Override
    public void run() {
        while (true) {
            System.out.println("hello world" + (++count));
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if (count == 10) {
                break;
            }
        }
    }
}

class T2 implements Runnable {

    int count = 0;

    @Override
    public void run() {
        while (true) {
            System.out.println("hi" + (++count));
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if (count == 5) {
                break;
            }
        }
    }
}

3. 如何理解线程