再谈 Java中Runnable和Thread的区别

在面试中老有面试官问这个问题，个人觉得这个问题问的没有技术，一个死记硬背就能回答的很好。但是更深的回答是什么了，那就是直接回答源码吧。 thread类实现了runnable 接口 ，Runnable就是一个借口 ，只能我们去实现了才能用 对吧，不管是普通类 还是匿名内部类 ，最大的区别是我们的自己的实现类 没有办法启动线程，还是要借助于thread

结果就出现了线程的实现方法

package test8;

/**
 * 方式一
 * @author suifeng
 *
 */
class myThread extends Thread{

@Override
public void run() {
// TODO Auto-generated method stub
System.out.println(Thread.currentThread());
}
}

/**
 * 方式二
 * @author suifeng
 *
 */
class myRunable implements Runnable{

@Override
public void run() {
// TODO Auto-generated method stub
System.out.println(Thread.currentThread());
}
}
public class DT {

public static void main(String[] args) {
// TODO Auto-generated method stub

new myThread().start();

new Thread(new myRunable()).start();


}

}

但是不管是什么方法都需要 thread类的start 方法告诉JVM 启动线程 ,start()方法被 synchronized 修饰 ，在方法块里面有调用了start0() 方法

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();

        /* Notify the group that this thread is about to be started
         * so that it can be added to the group's list of threads
         * and the group's unstarted count can be decremented. */
        group.add(this);

        boolean started = false;
        try {
            start0();
            started = true;
        } finally {
            try {
                if (!started) {
                    group.threadStartFailed(this);
                }
            } catch (Throwable ignore) {
                /* do nothing. If start0 threw a Throwable then
                  it will be passed up the call stack */
            }
        }
    }

 private native void start0();

start0方法是一个native 方法，直接调用的JVM C语言方法，才能启动一个线程 ，所以只有我们有办法启动这个start0,就可以自己创建一个线程 但是他又是一个私有方法 好吧，先我们来东东手，以后再也不用老是在实现runnable和在start()了

package test8;

import java.lang.Thread.State;
import java.lang.Thread.UncaughtExceptionHandler;

interface Work {

void work();
}

/**
 * 装饰模式  
 * @author suifeng
 *
 */
class Mthread implements Runnable {
Thread dt;
Work w;

public Mthread(Work w) {
dt = new Thread(this);
this.w = w;
dt.start();
}

public int hashCode() {
return dt.hashCode();
}

public boolean equals(Object obj) {
return dt.equals(obj);
}

public void start() {
dt.start();
}

// ...
public void run() {
w.work();
}

public final void stop() {
dt.stop();
}

public final void stop(Throwable obj) {
dt.stop(obj);
}

public void interrupt() {
dt.interrupt();
}

public boolean isInterrupted() {
return dt.isInterrupted();
}

public void destroy() {
dt.destroy();
}

public final boolean isAlive() {
return dt.isAlive();
}

public final void suspend() {
dt.suspend();
}

public final void resume() {
dt.resume();
}

public final void setPriority(int newPriority) {
dt.setPriority(newPriority);
}

public final int getPriority() {
return dt.getPriority();
}

public final void setName(String name) {
dt.setName(name);
}

public final String getName() {
return dt.getName();
}

public final ThreadGroup getThreadGroup() {
return dt.getThreadGroup();
}

public int countStackFrames() {
return dt.countStackFrames();
}

public final void join(long millis) throws InterruptedException {
dt.join(millis);
}

public final void join(long millis, int nanos) throws InterruptedException {
dt.join(millis, nanos);
}

public final void join() throws InterruptedException {
dt.join();
}

public final void setDaemon(boolean on) {
dt.setDaemon(on);
}

public final boolean isDaemon() {
return dt.isDaemon();
}

public final void checkAccess() {
dt.checkAccess();
}

public String toString() {
return dt.toString();
}

public ClassLoader getContextClassLoader() {
return dt.getContextClassLoader();
}

public void setContextClassLoader(ClassLoader cl) {
dt.setContextClassLoader(cl);
}

public StackTraceElement[] getStackTrace() {
return dt.getStackTrace();
}

public long getId() {
return dt.getId();
}

public State getState() {
return dt.getState();
}

public UncaughtExceptionHandler getUncaughtExceptionHandler() {
return dt.getUncaughtExceptionHandler();
}

public void setUncaughtExceptionHandler(UncaughtExceptionHandler eh) {
dt.setUncaughtExceptionHandler(eh);
}
}

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

new Mthread(new Work() {

@Override
public void work() {

System.out.println(Thread.currentThread());
}
});

new Mthread(new Work() {

@Override
public void work() {
// TODO Auto-generated method stub
System.out.println(Thread.currentThread());
}
});


while (Thread.activeCount() > 1) {
Thread.yield();
}

}
}