同一個線程多次調用start()會出現的問題

測試代碼：

package com.led.test;

/**
 * @author Alan
 * @date 2018/6/18 15:09
 * @description 測試同一個線程多次調用start()方法
 */
public class MuchStart implements Runnable{ //實現Runnable接口
    public void run() {
        System.out.println(Thread.currentThread().getName() + "is running ...");
    }

    public static void main(String[] args) {
        MuchStart muchStart = new MuchStart();
        Thread t = new Thread(muchStart);//創建實現了Runnable接口的Thread實例
        t.start();//多次調用start()方法
        t.start();
        t.start();
    }
}

測試結果：

　　線程首先會運行一次，然后拋出java.lang.IllegalThreadStateException異常。

 接下來深入源碼分析下原因：

　　我們根據控制台的異常信息，定位到Thread.java的第708行，也就start()方法內部，打個斷點調試：

 

 　　調試發現，第一個次運行start()方法時，threadStatus是0，此時if條件不滿足，繼續執行，會將當前線程添加到線程組中去執行。第二次運行start()方法時，threadStatus變成了2，if條件滿足，於是拋出了java.lang.IllegalThreadStateException異常。

Thread-0is running ...
Exception in thread "main" java.lang.IllegalThreadStateException
    at java.lang.Thread.start(Thread.java:708)
    at com.led.test.MuchStart.main(MuchStart.java:17)

start()源碼進行分析：

/**
     * Causes this thread to begin execution; the Java Virtual Machine
     * calls the <code>run</code> method of this thread.
　　　　  讓這個線程開始執行。JVM會調用這個線程的run()方法。
     * <p>
     * The result is that two threads are running concurrently: the
     * current thread (which returns from the call to the
     * <code>start</code> method) and the other thread (which executes its
     * <code>run</code> method).
     * <p>
     * It is never legal to start a thread more than once.一個線程多次調用start()方法是非法的。
     * In particular, a thread may not be restarted once it has completed
     * execution.
     *特別說明：一個線程執行完后，不太可能重新運行。
     * @exception  IllegalThreadStateException  if the thread was already
     *               started.
　　　　　　　　　　　　　　如果該線程已經啟動，則再次調用start()方法，就會拋出IllegalThreadStateException異常。
     * @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)//新的線程threadState值是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);//通知線程組該線程將要開始運行，這樣該線程就會被添加到線程列表中，此時列表的unstarted數將會減少。

        boolean started = false;
        try {
            start0();//調用原生方法態方法啟動線程
            started = true;//已經運行的標記設置為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 */
            }
        }
    }

group.add(this)  ---線程組添加線程源碼分析：

/**
     * Adds the specified thread to this thread group.
     * 添加特定的線程到該線程組
     * <p> Note: This method is called from both library code
     * and the Virtual Machine. It is called from VM to add
     * certain system threads to the system thread group.
     *
     * @param  t
     *         the Thread to be added
     *
     * @throws  IllegalThreadStateException
     *          if the Thread group has been destroyed
     */
    void add(Thread t) {
        synchronized (this) {//線程同步
            if (destroyed) {//如果線程組的銷毀標記(destroyed)是true，則拋出IllegalThreadStateException
                throw new IllegalThreadStateException();
            }
            if (threads == null) {//如果線程數組為空，則初始為4個新的線程
                threads = new Thread[4];
            } else if (nthreads == threads.length) {//如果當前線程組已滿，則擴容至原來的2倍
                threads = Arrays.copyOf(threads, nthreads * 2);
            }
            threads[nthreads] = t;//將當前線程放入線程數組的末尾

            // This is done last so it doesn't matter in case the
            // thread is killed
            nthreads++;//線程數組元素個數+1

            // The thread is now a fully fledged member of the group, even
            // though it may, or may not, have been started yet. It will prevent
            // the group from being destroyed so the unstarted Threads count is
            // decremented.
            nUnstartedThreads--;//未啟動線程數-1
        }
    }

 start0()代碼分析：

private native void start0();//原生態代碼，源碼不在當前文件中，調用的其它文件的代碼（可能是c/c++寫的代碼）

threadStartFailed()源碼分析：

/**
     * Notifies the group that the thread {@code t} has failed
     * an attempt to start.
     * 通知線程組該線程嘗試運行失敗
     * <p> The state of this thread group is rolled back as if the
     * attempt to start the thread has never occurred. The thread is again
     * considered an unstarted member of the thread group, and a subsequent
     * attempt to start the thread is permitted.
     *
     * @param  t
     *         the Thread whose start method was invoked
     */
    void threadStartFailed(Thread t) {
        synchronized(this) {//同步
            remove(t);//從線程組中移除該線程
            nUnstartedThreads++;//未啟動線程數+1
        }
    }

 總結：

　　同一個線程只能調用start()方法一次，多次調用會拋出java.lang.IllegalThreadStateException。啟動一個線程，需要調用start()方法而不是run()方法。此時，當前線程會被添加到線程組中，進入就緒狀態，等待線程調度器的調用，若獲取到了資源，則能進入運行狀態，run()方法只是線程體，即線程執行的內容，若沒調用start()方法，run()方法只是一個普通的方法。