线程八大核心基础——实现多线程

我们平时在使用多线程时，创建多线程最常用的是两种方式
1、继承Thread类，重写run()方法

public class CreateThread {

    static class ThreadTest extends Thread{
        @Override
        public void run() {
            System.out.println("测试");
        }
    }

    public static void main(String[] args) {
        ThreadTest threadTest = new ThreadTest();
        //启动线程
        threadTest.start();
    }

}

2、实现Runnable接口，重写run()方法

public class CreateThread {
    static class RunnableTest implements Runnable{
        @Override
        public void run() {
            System.out.println("测试");
        }
    }
    public static void main(String[] args) {
        Thread thread = new Thread(new RunnableTest());
        //启动线程
        thread.start();
    }
}

这两种方式算然都是可以实现创建多线程，但是本质上还是有区别的
首先我们看第一种创建的方式，他是先继承了Thread类然后重写了Thread类中的run方法
但是我们可以到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;
    private int            priority;
    private Thread         threadQ;
    private long           eetop;
    /* What will be run. */
    private Runnable target;
    ...此处省略一部分代码

    /**
     * If this thread was constructed using a separate
     * <code>Runnable</code> run object, then that
     * <code>Runnable</code> object's <code>run</code> method is called;
     * otherwise, this method does nothing and returns.
     * <p>
     * Subclasses of <code>Thread</code> should override this method.
     *
     * @see     #start()
     * @see     #stop()
     * @see     #Thread(ThreadGroup, Runnable, String)
     */
    @Override
    public void run() {
        if (target != null) {
            target.run();
        }
    }
    ...此处省略一部分代码

原来Thread类也是通过实现Runnable接口来实现的。调用start方法时最终也是调用了runnable接口“target.run()”。
而Runnable的方法就是整个方法被重写掉，运行时会调用run方法。

那么我们在开发中，这两种方式用哪一种更好呢？
答案是实现Runnable的方式来实现会更好，对于Java面向对象的设计特点，使用第二种方式可以避免Java特性中单根继承限制，而且对于相同程序代码的线程去处理同一个资源时，以Thread的方式是不方便的。所以可以总结以下几点

1.适合多个相同程序代码的线程去处理同一个资源（多线程内的数据共享）
2.避免java特性中的单根继承限制
3.增加程序健壮性，数据被共享时，仍然可以保持代码和数据的分离和独立
4.更能体现java面向对象的设计特点

那么Runnable的优势我们可以看到了，如果我同时用Thread和Runnable两种方式一起创建线程会怎么样？

new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("Runnable方式");
            }
        }) {
            @Override
            public void run() {
                System.out.println("Thread方式");
            }
        }.start();

输出结果为：Thread方式
这说明了Runnable接口中的匿名内部类是没有被执行的
由于Thread类的run方法是被重写过的，所以根据Java的特性，Thread类重的run方法是完全被覆盖了的，不会执行下面的target方法，因此也就不会走Runnable接口的方法了。

那我们再衍生的想以下，Java为什么会有两种实现线程的方式呢？一个不更好吗？其实这个是设计的准则而已，Runnable只是一个接口，并不干活，真正干活的是实现了Runnable的方法的类，就像Thread类一样，他不是结构，但他确实是帮助Java去创建线程的真正工作者。那么Runnbale存在的意义在哪呢？在上面我们讲了，在开发中使用实现Runnable比继承Thread类更好。其中最主要的目的就是Runnable能够实现数据共享，有着比继承Thread类更好的灵活性。

小结：
根据oracle官方，实现线程的方式只有两种，一是实现Runnable接口，二是继承Thread类
但其实准确的来讲创建线程的方式只有构造Thread类一种，而实现线程的执行单位有两种方式
1、实现Runnable接口的run方法，把Runnable实例传递给Thread类。
2、重写Thread的Run方法（继承Thread类）