Thread-啓動

創建線程

繼承

public class MyThread extends Thread{
    @override
    public void run(){
        // do something
    }
}

接口

public class MyTask implements Runnable{
    public void run(){
        // do something
    }
}

不過具體執行的時候，還是需要

new Thread(myTask).start()

雖然還存在更多的方式，但其實都是這兩種方法的衍生方式，這裏就不贅述。

---

唯一啓動方式

    @Override
    public void run() {
        if (target != null) {
            target.run();
        }
    }

全部的線程啓動方式都是如此，都是通過填充Thread進行的方法填充。

推薦填充方式

由於多繼承等問題，實際推薦的是Runnable的方式進行任務提交。

一個任務就相當於是代碼邏輯的無參方法調用，而且更加的方便。

new Thread(()->{
    // do something
}).start();

停止線程

停止線程很簡單

public void stop(){
    Thread.currentThread().stop();
}

但是問題來了，我們可能需要線程任務完成以後才關閉，否則容易造成數據丟失。

因此，stop方法不推薦使用，已經逐漸廢棄了。

---

java當中，採取的是信號通知，而非強制停止，也就是說，命令下達，執不執行還得看線程自己的。

public class Main {
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(){
            @Override
            public void run() {
                while(true){
                    if(isInterrupted()){
                        System.out.println("我收到了停止信號，可我就是不停");
                    }
                }
            }
        };
        t.start();
        t.interrupt();
    }
}

睡眠響應

問題來了，睡眠的時候怎麼相應呢，休眠的時候根本不佔據cpu，也就是沒有主動活動啊。

public class Main {
    public static void main(String[] args) throws InterruptedException {
        final Thread t = new Thread(){
            @Override
            public void run() {
                try {
                    sleep(100 * 1000);
                }catch (Exception e){
                    e.printStackTrace();
                }
            }
        };
        t.start();
        t.interrupt();
    }
}

活動的確沒有，不過會拋異常，通過監聽異常，就可以收到信號了。

java.lang.InterruptedException: sleep interrupted
	at java.lang.Thread.sleep(Native Method)
	at com.godme.thread.Main$1.run(Main.java:9)

public class Main {
    public static void main(String[] args) throws InterruptedException {
        final Thread t = new Thread(){
            @Override
            public void run() {
                while(true){try {
                    sleep(5 * 1000);
                    System.out.println("醒來第一件事，就是睡覺");
                    return;
                }catch (InterruptedException e){
                    System.out.println("睡覺呢， 別吵，我不聽，我不停， 我醒了就是要繼續");
                }
            }
            }
        };
        t.join();
        t.start();
        new Thread(){
            @Override
            public void run() {
                t.interrupt();
            }
        }.start();
    }
}

睡眠的時候是不care中斷標記的，只能通過異常來進行判斷，爲了填補邏輯漏洞，不要忘記異常捕獲哦。

睡眠阻塞

睡眠時候是沒有主動的管理的，連中斷都需要用異常來進行通知。

一個最關鍵的東西，鎖(LOCK)， 平時資源都會相互搶佔鎖，獨佔但是還醒着，一會也能讓出來。

但是如果處於睡眠，不清醒，昏迷狀態，那就不行了。相當於是哦，對了，然後就倒頭大睡的朋友。

這也是sleep, wait的弊端，因爲很多交互，必須清醒的時候才能響應。

如果lock + sleep + wait， 你就得去循環的揭開這個嵌套。