Java线程

一、Thread类

线程是操作系统的概念，操作系统内核实现了线程这样的机制，系统对外提供API，让用户可以通过API进行跟线程有关的编程。Java中的的Thread类对操作系统提供的API进行进一步的抽象和封装。

1.1创建线程

方法①：继承Thread，重写Thread中的run方法。
方法②：实现Runnable，重写Runnable中的run方法。
方法③：继承Thread，重写run，但是使用匿名内部类。
方法④：实现Runnable，重写run，但是使用匿名内部类。
方法⑤：lambda表达式创建线程(推荐写法)，lambda本质上是一个匿名函数(没有名字的函数，只用一次)，主要用来实现“回调函数”的效果。Java中不允许函数独立存在，在Java中的lambda本质是函数式接口(本质上还是没有脱离类)

Thread t = new Thread(() -> { });//{}中写重写的run方法的内容

1.2Thread类中的一些构造方法

Thread(String name)、Thread(Runnable target, String name)使创建线程的时候可以指定线程的名字，使得后续调试时用jdk中的jconsole.exe查看线程时根据线程名字更容易区分线程。

1.3Thread类中的一些属性

getId()：线程的身份Id，这个Id是Java给线程分配的，不是系统api提供的线程Id也不是PCB中的Id

getName()：获取线程名字

getState()：获取线程状态

getPriority()：虽然Java提供了api可以设置/获取进程的优先级，但是作用不大，因为在应用程序的角度很难察觉出优先级带来的差异，优先级影响到的是系统在微观上进行的调度

isDaemon()：是否为守护线程/后台线程
后台线程：后台线程没有执行结束不影响整个进程的结束
前台线程：前台线程没有执行结束，此时整个进程一定不会结束
默认情况下线程是前台线程

isAlive()：判断内核线程是否存在(“回调方法”执行完毕后内核线程就销毁了)
Thread对象的生命周期要比系统内核中的线程更长一些，所以可能出现Thread对象还在内核中的线程已经销毁了这种情况

1.4线程的终止/打断

Java中让线程终止的方法是让run()更快地执行完。
方法①：手动创建出标志位来作为run()的执行结束条件，比如下面的代码创建标志位为isQuit。

   private static boolean isQuit = false;//把isQuit设置为成员变量，此时lambda访问这个成员变量就不再是变量的捕获了，而是内部类中访问外部类的属性(lambda表达式是函数式接口相当于内部类)，此时就没有final之类的限制了
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(() -> {
            while (!isQuit) {
                System.out.println("线程工作中");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("线程工作完毕!");
        });
        t.start();
        Thread.sleep(5000);
        isQuit = true;
        System.out.println("设置 isQuit 为 true");
    }

方法①有缺点：需要手动创建变量；当新线程内部已经进入循环在sleep()的时候，这时主线程再修改变量作为循环的终止条件，新线程完成循环后再结束新线程，即主线程完成修改后新线程不能及时响应结束。所以由此引入写法②。
方法②：用Thread类中现成的标志位终止线程，这里面用到了Thread类中的currentThread()，isInterrupted()，interrupt()。

    public static void main(String[] args) {
        Thread t = new Thread(() -> {
            // Thread 类内部, 有一个现成的标志位, 可以用来判定当前的循环是否要结束.
            while (!Thread.currentThread().isInterrupted()) {//Thread.currentThread()是获取当前线程的实例相当于t，哪个线程调用currentThread()就会返回哪个线程的对象，isInterrupted()用于判断Thread对象内部的标志位是否为true
                System.out.println("线程工作中");
                try {
                    Thread.sleep(1000);//正常来说sleep会休眠时间到了才能唤醒，但t.interrupt()可以使sleep内部触发出现一个异常，从而打破休眠，sleep抛出异常时会自动清除t.interrupt()设置为true的标志位，使标志位重新恢复为false。为什么这样设定?因为Java希望当线程收到要终止这样的信号的时候能够让我们自由决定接下来如何处理，就是让我们有更多的可操作空间，有可操作空间的前提是出现异常
                } catch (InterruptedException e) {
                    // 1.不做处理，循环继续正常执行.
                    e.printStackTrace();
                    // 2. 加上一个 break, 表示让线程立即结束.
                    // break;
                    // 3. 做一些其他工作, 完成之后再结束.
                    //其他工作的代码写在这里.
                    break;
                }
            }
        });
        t.start();
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("让 t 线程终止. ");
        t.interrupt();//把Thread对象中的标志位设置为true，即使线程内部的逻辑出现阻塞(如有sleep)，使用这个方法也可以打破阻塞
    }

1.5线程等待

t是Thread类型的对象。
t.join()(哪个线程调用join哪个线程就去等待，哪个对象调用join哪个对象就被等)

t.join()工作过程：
①如果t线程正在运行中，此时“调用join()的线程”就会阻塞，一直阻塞到t线程执行结束为止
②如果t线程执行结束了，此时“调用join()的线程”就不会涉及到阻塞

还有join(long millis)//join的括号里写“超时时间”(最多等millis毫秒)
还有join(long millis, int nanos)//nanos是纳秒的意思，但这个纳秒意义不大。s、ms、us、ns是秒、毫秒、微秒、纳秒的意思。

1.6获取当前线程的引用

public static Thread currentThread();//哪个线程调用currentThread()就返回哪个线程对象的引用。

1.7休眠当前线程

public static void sleep(long millis) throws InterruptedException和public static void sleep(long millis, int nanos) throws InterruptedException//nanos是毫秒的意思，但这个毫秒的意义不大，因为比如sleep(1000)会存在一定精度误差。

系统会按照1000这个时间来让线程休眠，但是到达1000秒之后系统就会唤醒这个线程(线程从阻塞状态变为就绪状态)，但不是这个线程变为就绪状态后就能立即回到cpu上运行，线程回到CPU上运行之前有一个系统调度的开销。

二、线程的状态

NEW：Thread对象已经有了，start方法还没调用

TERMINATE：Thread对象还在，内核中的线程已经销毁了

RUNNABLE：就绪状态(线程已经在cpu上执行/线程正在排队等待上cpu执行)

TIMED_WAITING：阻塞，由于sleep/join这种固定时间的方式产生的阻塞

WAITING：阻塞，由于wait这种不固定时间的方式产生的阻塞

BLOCKED：阻塞，由于锁竞争导致的阻塞