java 多线程实现方式Thread和Runnable之间差异

 java中实现多线程的方式有两种：

      1.是继承Thread类。

      2.是实现Runable接口。

      3.实现Callable接口，通过Executor执行器执行。

 Runnable接口只有一个run()方法。

publicinterface Runnable {    /**     * When an object implementing interface <code>Runnable</code> is used     * to create a thread, starting the thread causes the object's     * <code>run</code> method to be called in that separately executing     * thread.     * <p>     * The general contract of the method <code>run</code> is that it may     * take any action whatsoever.     *     * @see     java.lang.Thread#run()     */    public abstract void run();}

  平常我们是通过Runnable方式实现多线程，其实Thread就是Runnable的一个实现类，可以查看Thread的源码。

publicclass Thread implements Runnable {    /* Make sure registerNatives is the first thing <clinit> does. */    private static native void registerNatives();    static {        registerNatives();    }    private char        name[];    private int         priority;    private Thread      threadQ;    private long        eetop;    /* Whether or not to single_step this thread. */    private boolean     single_step;    /* Whether or not the thread is a daemon thread. */    private boolean     daemon = false;    /* JVM state */    private boolean     stillborn = false;    /* What will be run. */    private Runnable target;    /* The group of this thread */    private ThreadGroup group;    /* The context ClassLoader for this thread */    private ClassLoader contextClassLoader;    /* The inherited AccessControlContext of this thread */    private AccessControlContext inheritedAccessControlContext;    /* For autonumbering anonymous threads. */    private static int threadInitNumber;    ....    public void run() {        if (target != null) {            target.run();        }    }

1.通过继承Thread的方式，只需要继承Thread类，然后重写run方法，把线程运行的代码放在其中，调用start方法启动线程。

public class Main {public static void main(String arg[]){Person p1=new Person("p1");Person p2=new Person("p2");p1.start();p2.start();}}class Person extends Thread {private String name;Person(String s){name=s;}@Overridepublic void run() {for(int i=0;i<50;i++)System.out.println(name+" is running");}}

  Thread start方法如下

public synchronized void start() {        /**     * This method is not invoked for the main method thread or "system"     * group threads created/set up by the VM. Any new functionality added      * to this method in the future may have to also be added to the VM.     *     * A zero status value corresponds to state "NEW".         */        if (threadStatus != 0)            throw new IllegalThreadStateException();        group.add(this);        start0();        if (stopBeforeStart) {        stop0(throwableFromStop);    }}

这里主要是调用了start0方法，这时一个native本地调用，底层使用c语言实现

private native void start0();

 2.实现Runnable接口

public class Main {public static void main(String arg[]){Runnable p1=new Person("p1");Runnable p2=new Person("p2");new Thread(p1).start();new Thread(p2).start();}}class Person implements Runnable {private String name;Person(String s){name=s;}@Overridepublic void run() {for(int i=0;i<50;i++)System.out.println(name+" is running");}}

实现方式和继承Thread相似，不过Runnable没有Start方式，所以通过创建一个Thread对象，Runnable相当于代码的逻辑部分，现在的执行、管理、结束交给Thread对象负责。

 public Thread(Runnable target) {     init(null, target, "Thread-" + nextThreadNum(), 0); }

Thread中有Runnable接口实现的引用；

private Runnable target;

当然还有其他的构造函数通过转换。

由于在JAVA中只能单继承，所以使用实现Runnable接口的方式更好，在实际开发中这种方式用的也比较多，这种方式也可以使业务逻辑和线程管理相分离。