1线程的创建方式

1.1直接继承Thread

class MyThread extends Thread {
        @Override
        public void run() {
            super.run();

        }
    }

1.2实现Runble接口

class MyRunble implements Runnable{

        @Override
        public void run() {

        }
    }

1.3实现Callable接口(这种方式严格意义上来说 并不是一种实现方式 本质上是Runnable的实现方式)

class MyCallable extends Callable<String>{

        @Override
        public String call() throws Exception {
            return "返回值";
        }
    }

1.4对应的调用方式

public static void main(String[] args){
        //方式一
        MyThread myThread = new MyThread();
        myThread.start();
        
        //方式二
        new Thread(new MyRunble()).start();
        
        //方式三(FutureTask最终派生自Runnable)
        FutureTask<String> futureTask = new FutureTask<String>(new MyCallable());
        new Thread(futureTask).start();
        futureTask.get();//获取返回值
    }

1.4不同创建方式的区别

采用继承Thread类方式：
　　　（1）优点：编写简单，如果需要访问当前线程，无需使用Thread.currentThread()方法，直接使用this，即可获得当前线程。
　　　（2）缺点：因为线程类已经继承了Thread类，所以不能再继承其他的父类。

采用实现Runnable接口方式：
　　　（1）优点：线程类只是实现了Runable接口，还可以继承其他的类。在这种方式下，可以多个线程共享同一个目标对象，所以非常适合多个相同线程来处理同一份资源的情况，从而可以将CPU代码和数据分开，形成清晰的模型，较好地体现了面向对象的思想。
　　　（2）缺点：编程稍微复杂，如果需要访问当前线程，必须使用Thread.currentThread()方法。

Runnable和Callable的区别：
　　　(1)Callable规定的方法是call(),Runnable规定的方法是run().
　　　(2)Callable的任务执行后可返回值，而Runnable的任务是不能返回值得
　　　(3)call方法可以抛出异常，run方法不可以，因为run方法本身没有抛出异常，所以自定义的线程类在重写run的时候也无法抛出异常
　　　(4)运行Callable任务可以拿到一个Future对象，表示异步计算的结果。它提供了检查计算是否完成的方法，以等待计算的完成，并检索计算的结果。通过Future对象可以了解任务执行情况，可取消任务的执行，还可获取执行结果。

start()和run()的区别
start()方法用来，开启线程，但是线程开启后并没有立即执行，他需要获取cpu的执行权才可以执行
run()方法是由jvm创建完本地操作系统级线程后回调的方法，不可以手动调用（否则就是普通方法）

2线程的停止方式

2.1stop()

暴力的停止，会造成危险和问题，不可使用，不详细介绍。

interrupt()

目前最优的办法，目的是为了完成run方法的运行。
调用interrupt()方法分为两种情况，当前线程是否调用了sleep，不同的情况，处理方式不一样。

2.2.1未调用

static class MyThread extends Thread {
        @Override
        public void run() {
            super.run();
            while (!isInterrupted()){
                System.out.println("MyThread run");
            }
        }
    }

public static void main(String[] args) throws ExecutionException, InterruptedException {
        //方式一
        MyThread myThread = new MyThread();
        myThread.start();

        Thread.sleep(2);
        //发射终止信号
        myThread.interrupt();

    }

运行截图：

image.png

这种方式就是改变isInterrupted的值，从而达到退出循环的目的，当然我们可以根据自己的实际情况来加入判断，从而完成run方法的运行，达到停止线程的目的。

isInterrupted是系统提供的，默认值是false所以我们在判断的时候要加上!。当我们调用interrupt()方法后，isInterrupted会被置为true。

2.2.1调用

static class MyThread extends Thread {
        @Override
        public void run() {
            super.run();
            while (!isInterrupted()){
                System.out.println("MyThread run");

                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

我们在之前代码的基础上加了sleep方法，这时我们发现，循环不能被停止了(调用代码不变)。

image.png

为什么我们只是让线程睡一觉，就不行了呢？
我们先看下sleep的源码

    public static native void sleep(long millis) throws InterruptedException;

通过源码我们发现，sleep方法会抛出一个InterruptedException异常。

当我们调用interrupt()方法后，如果线程调用sleep方法，那么就会抛出InterruptedException异常，而在抛出异常的时候，会清除中断标记。所以当循环进行下一次循环的时候，还是会满足条件，继续执行。

这里我们要注意的一点是，调用interrupt()方法后，调用sleep方法抛出异常的时候会清除中断标记，而wait不会。

要注意的是，如果我们没有调用interrupt()方法，调用sleep()方法的时候，是不会抛出异常的，这点我觉得很重要，因为这点我苦恼了半天，后来自己跑了几遍代码才发现是这么回事。

综上所述，我们得知了调用sleep()方法时会抛出InterruptedException异常，并且会清除中断标记，那么我们就可以在异常捕获阶段进行处理了。

static class MyThread extends Thread {
        @Override
        public void run() {
            super.run();
            while (!isInterrupted()){
                System.out.println("MyThread run");

                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    //根据自己的需要 再将isInterrupted置为true
                    interrupt();
                    e.printStackTrace();
                    //根据当前代码逻辑 我们可以直接终止循环
                    break;
                }
            }
        }
    }

2.1守护线程

我们也可以通过setDaemon()方法将线程设为守护线程，这样当被守护的线程执行完后，守护线程也就随之而结束了。

 public static void main(String[] args) throws ExecutionException, InterruptedException {
        //方式一
        MyThread myThread = new MyThread();
        myThread.setDaemon(true);
        myThread.start();
        Thread.sleep(1000);
//        //发射终止信号
//        myThread.interrupt();

    }

上面的代码也就是说myThread守护main线程 main线程结束 不管myThread是否结束 myThread都要结束。
(谁调用的myThread，myThread就守护谁，main线程调用的，myThread就守护main线程)