多线程与并发 - Thread和Runnable是什么关系_java中thread和runnable的关系

源码对比

Thread源码

Thread其实是一个类，并且这个类实现了Runnable接口。

Thread利用自身的start方法创建线程，执行实现了的run方法，使其具有多线程的特性

Runnable源码

Runnable其实是一个接口，这个接口很简单，只有一个抽象的run方法，那也就说明这个接口并不具有多线程的特性

实现多线程的方式对比

Thread

创建自己的线程类MyThread，继承Thread，重写run方法

public class Mythread extends Thread {
    private String name;
 
    public Mythread(String name) {
        this.name = name;
    }
 
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println("Thread ：" + this.name + ",i = " + i);
        }
    }
}

创建ThreadDemo类，实例化多个MyThread对象，并分别调用start方法创建新线程

public class ThreadDemo {
    public static void main(String[] args) {
        Mythread m1 = new Mythread("Thread1");
        Mythread m2 = new Mythread("Thread2");
        Mythread m3 = new Mythread("Thread3");
        m1.start();
        m2.start();
        m3.start();
    }
}

运行结果

Thread ：Thread3,i = 0
Thread ：Thread2,i = 0
Thread ：Thread1,i = 0
Thread ：Thread1,i = 1
Thread ：Thread1,i = 2
Thread ：Thread2,i = 1
Thread ：Thread3,i = 1
Thread ：Thread2,i = 2
Thread ：Thread2,i = 3
Thread ：Thread1,i = 3
Thread ：Thread2,i = 4
Thread ：Thread1,i = 4
Thread ：Thread3,i = 2
Thread ：Thread3,i = 3
Thread ：Thread3,i = 4

从执行结果可以看出，3个线程是交互执行的，也就达到了多线程的目的。

Runnable

由于Runnable没有start方法，而Thread有start方法，并且Thread的构造函数中是可以传入Runnable子类实例的，所以我们可以使用Thread类来启动Runnable实现多线程

创建MyRunnable类实现Runnable接口

public class MyRunnable implements Runnable {
    private String name;
 
    public MyRunnable(String name) {
        this.name = name;
    }
 
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println("Thread ：" + this.name + ",i = " + i);
        }
    }
}

创建RunnableDemo类，实例化多个MyRunnable对象，再将MyRunnable对象传入Thread构造函数实例化同等数量的Thread对象，并分别调用start方法创建新线程

public class RunnableDemo {
    public static void main(String[] args) {
        MyRunnable mr1=new MyRunnable("Runnable1");
        MyRunnable mr2=new MyRunnable("Runnable2");
        MyRunnable mr3=new MyRunnable("Runnable3");
        Thread r1=new Thread(mr1);
        Thread r2=new Thread(mr2);
        Thread r3=new Thread(mr3);
        r1.start();
        r2.start();
        r3.start();
    }
}

运行结果

Thread ：Runnable1,i = 0
Thread ：Runnable2,i = 0
Thread ：Runnable3,i = 0
Thread ：Runnable2,i = 1
Thread ：Runnable1,i = 1
Thread ：Runnable2,i = 2
Thread ：Runnable3,i = 1
Thread ：Runnable2,i = 3
Thread ：Runnable2,i = 4
Thread ：Runnable1,i = 2
Thread ：Runnable1,i = 3
Thread ：Runnable1,i = 4
Thread ：Runnable3,i = 2
Thread ：Runnable3,i = 3
Thread ：Runnable3,i = 4

同样，从执行结果可以看出，3个线程是交互执行的，也达到了多线程的目的。

总结

• Thread是实现了Runnable接口的类，使得run支持多线程（Thread实现了Runnable接口并进行了扩展，而Thread和Runnable的实质是实现的关系）
• Runnable的多线程实现方式是实现其接口
• Thread的多线程实现方式是继承其类
• 因为类的单一继承原则，推荐使用Runnable接口（实现Runnable接口的同时可以实现其它接口或继承其它类，提升可扩展性）