摘要：另外一種方法是，將這個線程加入一個線程組，在線程組里重寫方法來處理拋出的異常，這時線程組的作用相當于實現了的類。使用對象處理異常格式錯誤使用線程組處理異常測試異常

感性地理解一下什么是線程？

線程這個概念其實是比較抽象的，雖然依照教科書上的說法：

進程是從系統獲取資源的最小單位，線程是程序執行的最小單位。程序是靜態存在于磁盤上的一段文本，進程運行這段文本記錄的命令。

也就是說，進程從系統那里獲取到了一定的CPU占用時間片、內存單元和IO等等資源，然后線程將這些資源利用起來執行程序，線程執行程序是什么意思呢？就是把程序記錄的那些命令逐條依序一步步在CPU上運作，數據在內存、IO上流轉，將命令執行完。
這個層級的概念存在于OS上，OS的調度抽象層級并不是那么直觀，如果我們在說明白一點，在做底層的計算機組成原理實驗的時候，在我們接好連線后硬件就具有了處理數據的能力，只要扳動不同的開關就可以將數據讀寫在不同的芯片上，我們的程序也許是為了完成數據流轉寫在紙上的扳動不同開關的序列，所以程序是屬于IO級別的，然后我們依照紙上的命令序列實際上手去扳動不同的開關執行的就是這段程序，所以我們自己充當的角色就是進程，最終就得出了這樣的結論：進程“執行”程序。至于線程呢，可以看作是進程在執行過程中的策略，比如說在一個人扳動開關的時候就是單進程單線程，如果是兩個人扳動開關就是單進程多線程，如果兩個人能配合起來扳動開關就是多線程同步，所以線程和進程之間并非互斥的概念，而是相容的概念，如果有線程就一定有進程，一個進程包含了至少一個的線程。

創建線程的方法
1.創建直接創建Thread的子類，重寫run()方法；

class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println("This is my thread");
    }
}

public class Test {
    public static void main(String[] args) {
        MyThread thread = new MyThread();
        thread.start();
    }
}

2.創建一個線程執行類實現Runnable接口，在這個執行類里實現Runnable的run()方法，創建該執行類的對象后，用此執行類對象初始化新線程，啟動新線程時即執行這個執行對象的run()方法；

class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("This is my thread");
    }
}

public class Test {
    public static void main(String[] args) {
        Thread thread = new Thread(new MyRunnable());
        thread.start();
    }
}

3.通過線程工廠用工廠模式來創建新線程，新建工廠類繼承ThreadFactory類重寫newThread()方法，通過指定實現了Runnable接口的執行類來創建與之對應的線程；

public class ThreadFactoryDemo {

    public static void main(String[] args) {
        ThreadFactory factory = new ThreadFactory() {

            @Override
            public Thread newThread(Runnable r) {
                // TODO Auto-generated method stub
                return new Thread(r);
            }
        };
        factory.newThread(new Runnable() {

            @Override
            public void run() {
                System.out.println("in runnable.");

            }
        }).start();
    }

}

注意：只有調用Thread類的Start方法，才能真正地在一個獨立的線程中執行代碼，直接調用Thread類的run方法，并不能啟動一個新的線程，代碼是在調用者線程中執行的。

那么主線程的run()方法在哪里呢？任何java程序的main執行入口擔當著啟動主線程的作用，只要進入了main函數就執行了主線程，因此整個main函數里的內容就是主線程的run()方法。

線程究竟執行哪個run()方法
當線程同時具有可執行對象實現的run()方法和線程重寫的run()方法時，啟動線程時究竟執行哪個run()方法呢？
結果是如果只定義了可執行對象的run()方法則執行這個run()方法，如果只重寫了線程的run()方法則執行這個run()方法，如果兩個方法都有則執行線程重寫的run()方法。

public class Test {
    public static void main(String[] args) {
        Thread thread = new Thread(new Runnable() {

            @Override
            public void run() {
                System.out.println("Runnable.run()");

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

線程的休眠
使用Thread類的sleep()方法或者使用TimeUnit的相關方法來休眠線程，休眠的意思是資源仍被占用，但是線程保留原來的狀態沒有活動；

public class ThreadSleep {
    public static void main(String[] args) {
        Thread th = new Thread(new Runnable() {
            public void run() {
                for (int i = 0; i < 10; i++) {
                    try {
                        // Thread.sleep(500);
                        TimeUnit.SECONDS.sleep(1);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }

        });
        th.start();
    }
}

線程中斷
線程中斷的意思是線程停止當前的運行狀態讓出資源結束生命周期，當外界想要一個線程中斷時需要調用它的interrupted()方法，調用后不是直接就可以中斷這個線程，而是將線程的interrupted標記位賦為1，如果要線程要響應這個中斷則定期需要檢查這個標記，檢查到被中斷標記后自己退出執行狀態。

public class ThreadInterruptDemo {
    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread() {
            @Override
            public void run() {
                while (true) {
                    System.out.println("running");
                    if (isInterrupted())
                        return;
                }
            }
        };
        thread.start();
        Thread.sleep(2000);
        thread.interrupt();
    }
}

線程定時任務
線程要實現定時任務的話可以使用Runnable的實現類TimerTask，此類需要重寫run()方法以完成具體需要進行的定時任務。然后由定時器Timer來調度，使用Timer的schedle()方法相當于啟動這個定時任務線程。

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

        TimerTask task = new TimerTask() {
            private int counter = 0;

            @Override
            public void run() {
                System.out.println(counter + ":invoked!");
                counter++;
            }
        };
        Timer timer = new Timer();
        // 過2秒鐘后首次運行，以后每隔3秒運行一次
        timer.schedule(task, 2000, 3000);
    }
}

線程運行過程中的異常處理
線程的run()方法中是不允許直接拋出異常的，也就是說不能有這樣的寫法：run() throws Exception ,原因在于在線程的運行過程中應該最大限度地保持正常工作，因此除了一些不可預知的運行時異常，不應該主動拋出受控異常。如果非要在run()方法里處理拋出的異常，則應該定義一個實現了UncaughtExceptionHandler的類，然后指定這個類的對象在重寫的uncaughtException()方法里去處理拋出的異常。另外一種方法是，將這個線程加入一個線程組，在線程組里重寫uncaughtException()方法來處理拋出的異常，這時線程組的作用相當于實現了UncaughtExceptionHandler的類。

1.使用handler對象處理異常：

public class ThreadTest {
    public static void main(String[] args) {
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                throw new RuntimeException("格式錯誤");
            }
        });
        thread.setUncaughtExceptionHandler(new MyHandler());
        thread.start();
    }
}

class MyHandler implements UncaughtExceptionHandler {
    @Override
    public void uncaughtException(Thread t, Throwable e) {
        System.out.println(t.getName() + ":" + e.getMessage());

    }
}

2.使用線程組處理異常：

public class ThreadGroupDemo {
    public static void main(String[] args) {
        ThreadGroup threadGroup1 = new ThreadGroup("group1") {
            public void uncaughtException(Thread t, Throwable e) {
                System.out.println(t.getName() + ": " + e.getMessage());
            }
        };
        Thread thread1 = new Thread(threadGroup1, new Runnable() {
            public void run() {
                throw new RuntimeException("測試異常");
            }
        });

        thread1.start();
    }
}