526互联

Runnable和Thread比较

发布时间 2023-05-03 20:38:45作者: ImreW

（一）Thread类实现了Runnable接口吗？

在线程使用过程中，我们肯定会用到Runnable与Thread，前者的实现方式是实现其接口即可，后者的实现方式是继承其类。两者实现方式带来最明显的区别就是，由于Java不允许多继承，因此实现了Runnable接口可以再继承其他类，但是Thread明显不可以。

我们看看源码中对与Thread类的部分声明

    public class Thread implements Runnable {
    /* Make sure registerNatives is the first thing <clinit> does. */
    private static native void registerNatives();
    static {
        registerNatives();
    }

    private volatile String name;
    ...

Thread 类是实现了Runnable接口的。

（二）实现多线程的两种方法

第一种方法：继承Thread类

方法步骤总结：

  1. 定义一个类继承Thread；
  2. 重写Thread类中的run方法，将需要被多线程执行的代码存储到该run方法当中。
  3. 建立Thread类的子类创建线程对象。
  4. 直接调用子类从Thread类继承的start方法，开启一个线程（调用该线程的run方法）。

第二种方法：实现Runable接口

Thread类有一个Thread(Runnable target)构造方法，在Runable接口类中只有一个run()方法。

当使用Thread(Runnable target)方法创建线程对象时，需要为该方法传递一个实现 Runnable接口的对象，这样创建的线程将调用那个实现了Runnable接口类对象中的run()方法作为其运行代码，而不再是调用Thread类中的run方法了。

方法步骤总结：

  • 定义一个类实现Runnable接口，覆盖Runnable接口中的run方法，将线程要运行的代码存放在该run方法中；
  • 通过Thread类建立线程对象，将Runnable接口的子类实例对象作为实际参数传递给Thread类的构造方法。
Thread readerThread = new Thread(new IncomingReader());
readerThread.start();

class IncomingReader implements Runnable{
...
}

两种方式区别

  • 继承Thread: 线程代码存放Thread子类run方法中，且该run方法被调用。
  • 实现Runnable：线程代码存在实现了Runnable类接口的对象的run方法中，且该run方法被调用。

注意：启动一个新的线程，不是直接调用Thread子类的对象的run方法，而是调用Thread子类对象的start方法。

start方法是从Thread类中继承的方法，Thread类对象的start方法将产生一个新的线程，并在该线程上运行该Thread类对象中的run方法。

根据面向对象的多态性可知，在该线程上实际运行的是我们编写的那个类（Thread的子类）对象中的run方法。

（三）Runnable和Thread比较

如上所述，Runnable相比Thread存在明显的优点，同时也是两者最大的区别。这点就不再做阐述，这里对于网络很多文章中存在的明显的错误文字总结进行一下论证：

Runnable可以实现多个相同的程序代码的线程去共享同一个资源，而Thread不可以？

我们以实际的代码样例来论证这个观点：

package test;

/**
 * Thread 实现资源共享
 * @author itbird
 *
 */
public class Test2 {

    public static void main(String[] args) {
        MyThread t1 = new MyThread();
        new Thread(t1, "线程1").start();
        new Thread(t1, "线程2").start();
    }

    public static class MyThread extends Thread {
        private int total = 10;

        @Override
        public void run() {
            for (int i = 0; i < 10; i++) {
                synchronized (this) {
                    if (total > 0) {
                        try {
                            Thread.sleep(100);
                            System.out.println(Thread.currentThread().getName() + "卖票---->" + (this.total--));
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
        }
    }
}

Thread实现共享同一个资源

package test;

/**
 * Runnable 实现资源共享
 * @author itbird
 *
 */
public class Test3 {

    public static void main(String[] args) {
        MyRunable t1 = new MyRunable();
        new Thread(t1, "线程1").start();
        new Thread(t1, "线程2").start();
    }

    public static class MyRunable implements Runnable {
        private int total = 10;

        @Override
        public void run() {
            for (int i = 0; i < 10; i++) {
                synchronized (this) {
                    if (total > 0) {
                        try {
                            Thread.sleep(100);
                            System.out.println(Thread.currentThread().getName() + "卖票---->" + (this.total--));
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
        }
    }
}

Runnable实现共享同一个资源

经过实际样例代码编写以及运行结果对比，我们知道很多人说的Thread类不能共享资源，其实并不是不能，只是不适合

其实我们从Thread源码中也可以看到，当以Thread方式去实现资源共享时，实际上源码内部是将thread向下转型为了Runnable，实际上内部依然是以Runnable形式去实现的资源共享

（四）Runnable为什么不可以直接run

多线程原理：相当于玩游戏机，只有一个游戏机（cpu），可是有很多人要玩，于是，start是排队！等CPU选中你就是轮到你，你就run（），当CPU的运行的时间片执行完，这个线程就继续排队，等待下一次的run（）。

调用start（）后，线程会被放到等待队列，等待CPU调度，并不一定要马上开始执行，只是将这个线程置于可动行状态。然后通过JVM，线程Thread会调用run（）方法，执行本线程的线程体。先调用start后调用run，这么麻烦，为了不直接调用run？就是为了实现多线程的优点，没这个start不行。

  1. start（）方法来启动线程，真正实现了多线程运行。这时无需等待run方法体代码执行完毕，可以直接继续执行下面的代码；通过调用Thread类的start()方法来启动一个线程， 这时此线程是处于就绪状态， 并没有运行。 然后通过此Thread类调用方法run()来完成其运行操作的， 这里方法run()称为线程体，它包含了要执行的这个线程的内容， Run方法运行结束， 此线程终止。然后CPU再调度其它线程
  2. run（）方法当作普通方法的方式调用。程序还是要顺序执行，要等待run方法体执行完毕后，才可继续执行下面的代码； 程序中只有主线程——这一个线程， 其程序执行路径还是只有一条， 这样就没有达到写线程的目的

解释到这里，相信各位看官心里有种“了然大明白”的感觉，runnable其实相对于一个task，并不具有线程的概念，如果你直接去调用runnable的run，其实就是相当于直接在主线程中执行了一个函数而已，并未开启线程去执行，所以显而易见，如果你在代码中直接通过这种方式run了一个runnable，明显您的程序的主线程就直接悲催了，各种资源不足现象的崩溃日志会接踵而至，而且遇到这种问题的时候，如果没有一定的研发经验和坚持，很有可能采取错误的解决策略。