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， 你就得去循环的揭开这个嵌套。