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

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

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

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

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

創(chuàng)建線程的方法
1.創(chuàng)建直接創(chuàng)建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.創(chuàng)建一個線程執(zhí)行類實現(xiàn)Runnable接口，在這個執(zhí)行類里實現(xiàn)Runnable的run()方法，創(chuàng)建該執(zhí)行類的對象后，用此執(zhí)行類對象初始化新線程，啟動新線程時即執(zhí)行這個執(zhí)行對象的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.通過線程工廠用工廠模式來創(chuàng)建新線程，新建工廠類繼承ThreadFactory類重寫newThread()方法，通過指定實現(xiàn)了Runnable接口的執(zhí)行類來創(chuàng)建與之對應的線程；

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

}

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

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

線程究竟執(zhí)行哪個run()方法
當線程同時具有可執(zhí)行對象實現(xiàn)的run()方法和線程重寫的run()方法時，啟動線程時究竟執(zhí)行哪個run()方法呢？
結(jié)果是如果只定義了可執(zhí)行對象的run()方法則執(zhí)行這個run()方法，如果只重寫了線程的run()方法則執(zhí)行這個run()方法，如果兩個方法都有則執(zhí)行線程重寫的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的相關方法來休眠線程，休眠的意思是資源仍被占用，但是線程保留原來的狀態(tài)沒有活動；

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

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

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

線程定時任務
線程要實現(xiàn)定時任務的話可以使用Runnable的實現(xiàn)類TimerTask，此類需要重寫run()方法以完成具體需要進行的定時任務。然后由定時器Timer來調(diào)度，使用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()方法里處理拋出的異常，則應該定義一個實現(xiàn)了UncaughtExceptionHandler的類，然后指定這個類的對象在重寫的uncaughtException()方法里去處理拋出的異常。另外一種方法是，將這個線程加入一個線程組，在線程組里重寫uncaughtException()方法來處理拋出的異常，這時線程組的作用相當于實現(xiàn)了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();
    }
}