Thread类的介绍

线程是操作系统中的概念，操作系统中的内核实现了线程这种机制，同时，操作系统也提供了一些关于线程的API让程序员来创建和使用线程。

在JAVA中，Thread类就可以被视为是对操作系统中提供一些关于线程的API的的进一步的封装。

多线程程序的特点

1.每一个线程都是一个执行流

2.CPU对线程的执行是并发执行，同时对线程的执行也是随机调度的。

1.创建线程

1. 通过Thread类创建线程

class  MyThread extends Thread{
    @Override
    public void run() {
        while(true){
            System.out.println("hello Thread");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

    }
}
public class Demo1 {
    public static void main(String[] args) throws InterruptedException {
        Thread t= new MyThread();
        t.start();
        while(true){
            System.out.println("hello main");
            Thread.sleep(1000);
        }
    }
}

我们通过创建一个Thread类的子类MyThread，重写Thread类中的run方法，并通过MyThread子类来创建一个线程的实例化对象，run方法是线程的入口函数。而在主函数中的start方法，表示创建一个线程，且一个线程只能start一次。 

当我们运行上面代码，发现打印的内容的顺序会变换，这是因为多线程的影响，上面代码中有两个线程，分别位t线程和主线程，由于线程在CPU上是并发执行的，且又因为CPU对线程又是随机调度的，这就导致我们两个线程的执行顺序会改变，自然而然打印的顺序也会改变。

2.通过Runnable接口来创建线程

class MyRunnable implements Runnable{
    @Override
    public void run() {
        while (true){
            System.out.println("hello t");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
public class Demo2 {
    public static void main(String[] args) {
        Runnable runnable=new MyRunnable();
        Thread t=new Thread(runnable);
        t.start();
    }
}

3. 通过匿名内部类来创建线程

匿名内部类的写法本质完成了3件事

1.创建了一个Thread的子类，不知到该子类的名字，所以为匿名。

2.{ }代码块里面可以编写子类的定义代码，需要哪些属性，需要重写哪些父类的方法等等。

3. 创建了匿名内部类的实例，并将该实例传给了t1.

3.1 Thread

    public static void main(String[] args) throws InterruptedException {
        Thread t1=new Thread(){
            @Override
            public void run() {
                while(true){
                    System.out.println("hello t");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        };
        t1.start();
        while (true){
            System.out.println("hello main");
            Thread.sleep(1000);
        }
    }

3.2 Runnable接口

public static void main(String[] args) throws InterruptedException {
        Runnable runnable=new Runnable() {
            @Override
            public void run() {
                while(true){
                    System.out.println("hello t");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        };
        Thread t=new Thread(runnable);
        t.start();
        while (true){
            System.out.println("hello main");
            Thread.sleep(1000);
        }
    }

4.通过Lambda表达式式创建线程-----  ()->{}

由于Java中，方法必须依附于类的体系中，由于Lambda表达式本质就是一个回调函数，所以，为了快速实现这个回调函数，在Java中，就创建了一个函数式接口----- ()->{ },{ }代码块可以写上回调函数所需要功能的代码。

public static void main(String[] args) throws InterruptedException {
        Thread t=new Thread(()->{
            while (true){
                System.out.println("hello t");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        t.start();
        while (true){
            System.out.println("hello main");
            Thread.sleep(1000);
        }
    }

2.Thread类及常见方法

Thread类是JVM用来管理线程的一个类，也就是说，每个线程都有唯一的Thread类对象与之相关联。在Java中，每一个执行流（线程）都要用一个对象来表示，而Thread类对象就可以用来表示一个线程执行流，JVM会将这些Thread类对象组织起来，进行线程调度和线程管理。

2.1 Thread类常见的构造方法

注释：关于线程的名字，我们可以通过Jconsole来观察。

2.2 Thread的几个常见属性

1.ID是线程的唯一标识，不同线程的ID不会重复

2.名称是各种调试工具用到

3.状态表示线程当前所处的一个状态

4.优先级高的线程理论上更容易被CPU调度到

5.关于后台线程：线程分为后台线程（守护线程）和前台线程（用户线程）。我们需要记住一点：JVM会在一个线程中的所有的前台线程结束之后，JVM才会选择退出（程序终止执行）。也就是说，后台线程的存在不会阻止JVM的终止，相反，前台线程的存在会阻止JVM的终止，即使主线程已经结束。在Java中，线程在默认情况下是后台线程，例如垃圾回收机制就是一种后台线程。但是我们可以通过调用setDaemon(true)方法将一个线程设置为后台线程。

6.是否存活，可以简单理解为run方法是否运行结束。

2.3 如何启动一个线程----start()

一个线程对象被创建出来并不意味着线程就开始运行了。我们需要去调用start方法，接着线程中的run方法就会自动执行，只有run方法执行以后，一个线程才是真正运行起来。而调用了start方法，才是真正的在操作系统的层面建立了一个线程。

如下图：

2.4 中断一个线程

中断一个线程就是让该线程直接停止掉，不会再回复。中断一个线程就是让该线程的run方法（入口方法）尽快结束掉。

目前常见终止线程的方式有以下两种方式：

1.通过共享的标记来沟通

2.调用interrupt()方法来通知

1.通过共享的标记来沟通

该方法是通过设计一个外部成员变量来终止一个线程。

如以下代码

public class Demo9 {
    public static boolean isFinished=false;//共享标记
    public static void main(String[] args) throws InterruptedException {
        Thread t=new Thread(()->{
            while (!isFinished){
                System.out.println("hello t");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        t.start();
        Thread.sleep(3000);
        System.out.println("main尝试终止线程t");
        isFinished=true;
    }
}

我们通过isFinished 这个外部成员变量的值来通知操作系统是否终止t线程。

运行结果

注意事项：我们不能将该外部成员变量设置成一个局部变量 。否则会报出以下错误

原因解释：

这就涉及到变量捕获的问题 。简单来说，就是lambda表达式希望可以使用外面的变量，触发“变量捕获”的语法。由于lambda是一个回调函数，执行时机是很久以后，当操作系统真正创建出线程之后，才会执行。很有可能在创建线程的过程中，main线程就已经运行结束了,自然而然，身为局部变量的isFinished就会被销毁了。

为了解决这个问题，Java中的做法是，将被捕获的变量拷贝一份到lambda里面，外面变量的是否销毁，就不影响lambda里面的执行了。拷贝就以为着该变量就不适合被修改，尽管你在外面修改了这一变量的值，也不会影响拷贝到内部的值（本质上，被拷贝的变量和拷贝的变量是两个变量）

这种一边变，一边不变，可能给程序员带来更多的疑惑。所以在Java中就规定了，拷贝的变量就压根不允许被改变。所以后面修改isFinished的值时会报一个isFinished should be final or effectively final 的错，因为在Java中，被final修饰的变量是无法被修改的。

那为什么将isFinished设置为成员变量会没事呢？

因为当isFinished是一个成员变量时，此时触发的语法不在是“变量捕获”，而是切换成“内部类访问外部类的成员”的语法。

那是lambda表达式本质上是一个函数式接口，也相当于是一个内部类。isFinished本身就是一个外部类成员，内部类本来就能够访问外部类的成员。由于成员变量的生命周期是让GC（垃圾回收）来管理的，GC可以自动识别不在被引用的的对象，并将其占用的内存空间释放掉。所以在lambda里面就不必担心变量生命周期失效的问题，也就不必拷贝，也就不必有被final修饰的限制。

2.使用interrupt()方法来通知

Java的Thread类中提供了现成的方法直接进行判定线程方法是否被终止，不需要我们自己在创建了。

thread收到通知的方式有两种：

1.如果线程因为调用wait/join/sleep等方法而阻塞挂起，则以InterruedException异常的形式通知，清楚中断标志 ，当出现InterruedException的时候，要不要结束进程取决于catch中代码的写法，可以忽略该异常，也可以跳出循环结束进程。

2.否则，只是内部的一个中断标志位被设置了，可以通过isInterrupted()方法判断中断标志是否被设置，不清除中断标志，这种方法通知收到的更及时，即使线程在sleep也可以马上收到。

public class Demo10 {
    public static void main(String[] args) throws InterruptedException {
        Thread t=new Thread(()->{
            while (!Thread.currentThread().isInterrupted()){
                System.out.println("hello t");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                      e.printStackTrace();//报异常，清楚中断标志
                    //break;//跳出循环，结束进程
                    //啥都不写，忽略异常，进程继续执行
                }
            }
        });
        t.start();
        Thread.sleep(3000);
        System.out.println("main尝试终止线程t");
        t.interrupt();
    }
}

注意事项：针对上述代码由于每次循环，线程大部分时间在处sleep状态，当主线程调用interrup()方法时，会大概率唤醒sleep方法， sleep方法就会报InterruedException异常。

正常来说，调用interrupt()方法就会将isInterrupted()方法内部的标志位改为true，但是上述代码，能够把sleep()方法唤醒，sleep方法在唤醒之后就会将isInterrupted()方法内部的标志位的值重新改为false。因此在进程不结束的情况下，如果继续执行到循环的条件判断，就会发现能够继续执行循环中的代码。

2.5 等待一个线程-----join()

有时我们需要等到一个线程完成它的所有操作后，才进行下一步操作。这时候就用到了join()方法。

public class Demo11 {
    public static void main(String[] args) throws InterruptedException {
        Thread t=new Thread(()->{
            for(int i=0;i<3;i++){
                System.out.println("hello t");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        t.start();
        System.out.println("main线程在等t线程结束");
        t.join();
        System.out.println("t线程结束，main线程结束");
    }
}

上面的代码中，主线程中线程对象t调用了join方法，这就意味着main线程必须要先等待t线程结束后，才会执行main线程里面的内容。 

运行代码

如果调用的是join(long millis)版本，则会表示main线程只会等待t线程millis秒，不管t线程在这段时间内是否终止，main线程不会在等待t线程，而是继续执行自己的任务。 

public class Demo11 {
    public static void main(String[] args) throws InterruptedException {
        Thread t=new Thread(()->{
            for(int i=0;i<3;i++){
                System.out.println("hello t");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        t.start();
        System.out.println("main线程在等t2秒");
        t.join(2000);
        System.out.println("2秒内t线程没有结束，main线程不在等待，执行main线程");
    }
}

 2.6 获取当前线程引用

2.7 休眠当前线程-----sleep()

 关于sleep方法，有一点我们需要记得，因为线程调度是不可控的，所以，sleep方法只能保证实际休眠时间是大于等于参数设置的休眠时间的。

 这是因为调用sleep方法，相当于让当前线程，让出cpu的资源。后续休眠时间结束的时候，该线程需要操作系统内核时，操作系统会将该线程重新调度到cpu上，该线程才能继续执行。

换言之，sleep的时间到了，意味着该线程可以被调度，而不是立即执行，所以实际休眠时间会大于等于参数设置的休眠时间。

特殊用法：sleep(0)

sleep(0)意味着让当前线程立刻放弃CPU资源，等待操作系统重新调度。

 3.线程状态

从操作系统的角度来看，进程的有就绪和阻塞的两种状态。

Java线程也是对操作系统中的线程的重新封装。所以，针对线程的状态，Java中也重新进行了封装。