Thread类的run和start

public class Thread implements Runnable{

}

  //无参构造方法，自动生成name
  public Thread()

  //字符串构造方法，传入一个字符串给线程命名
  //可以用Thread类的get/setName方法对name进行访问和修改
  public Thread(String name)

  //传入Runnable接口实现
  public Thread(Runnable target)

  //传入一个线程组、一个Runnable接口实现
  //其中线程组中的基本单元既可以是线程也可以是线程组，进而组成一棵线程树
//除初始线程组之外，每个线程组有一个父线程
  public Thread(ThreadGroup group, Runnable target)

  //传入线程组、线程名
  public Thread(ThreadGroup group, String name)

  //传入Runnable接口实现，传入线程名
  public Thread(Runnable target, String name)

  //线程组、线程名、Runnable接口实现三者都传入
  public Thread(ThreadGroup group, Runnable target, String name)

  //多了一个stackSize，用于指定该线程申请的堆栈大小，不指定时默认为0
  //对于stackSize这个值如何使用，则由虚拟机自行决定
  //有些虚拟机会忽略这个值
  public Thread(ThreadGroup group, Runnable target, String name, long stackSize)

@FunctionalInterface
public interface 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();
}

/**
     * Causes this thread to begin execution; the Java Virtual Machine
     * calls the 'run' method of this thread.
     * 
     * The result is that two threads are running concurrently: the
     * current thread (which returns from the call to the start method) 
     * and the other thread (which executes its run method).
     * 
     * It is never legal to start a thread more than once.
     * In particular, a thread may not be restarted once it has completed
     * execution.
     *
     * @exception  IllegalThreadStateException  if the thread was already
     *               started.
     * @see        #run()
     * @see        #stop()
     */
    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 */
            }
        }
    }

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