多线程之旅：属性及其基本操作

上次分享到了，多线程中是是如何创建的，那么接下来，小编继续分享下多线程的相关知识。

多线程中的一些基本属性。

基本属性

属性	获取方法
ID	getId()
名称	getName()
状态	getState()
优先级	getPriority()
是否后台线程	isDemo()
是否存活	isAlive()
是否被中断	isInterrupted()

那么其中这些属性名称有着什么意思呢？

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

这里是jvm自动分配的，不能手动设置

名称：是各种调试工具用到的东西，可以帮助调试和日志记录

Thread对象的身份标识

状态：表示线程当前所处的一个情况

一般初学听的更多是就绪/阻塞

后面详细介绍。

优先级：影响线程调度一个工具，理论上来说，优先级高的更容易被调度到

设置不同的优先级，会影响系统的调度，这里的影响有着多种因素：

操作系统调度算法、优先级映射……

后台线程：特殊类型的线程，主要是为程序提高服务和支持功能。

有着后台线程，那么也有着前台线程

那么又是前台线程呢？

前台线程也是一个特殊线程，默认创建的。

有个值得注意的，前台线程会影响jvm的退出，前台线程结束后，jvm才会退出。

后台线程是不会影响jvm的退出的。

存活：可以简单理解为，执行run方法是否结束了

线程中断：用于请求线程停止当前工作的一种机制。

ok，接下来以一个代码来演示下

public static void main(String[] args) {
        Thread t=new Thread(()->{
           while (true){
               System.out.println("hello world");
               try {
                   Thread.sleep(1000);
               } catch (InterruptedException e) {
                   throw new RuntimeException(e);
               }
           }
        });
        t.start();
        //获取线程属性//获取ID
        System.out.println("ID:"+t.getId());
        //线程名字
        System.out.println("name:"+t.getName());
        //线程状态
        System.out.println("状态："+t.getState());
        //线程优先级
        System.out.println("优先级："+t.getPriority());
        //是否是后台线程
        System.out.println("前台/后台:"+t.isDaemon());
        //是否存活
        System.out.println("是否存活："+t.isAlive());
        //是否被中断
        System.out.println("是否被中断："+t.isInterrupted());
    }在代码运行期间，截了以下的运行图：

从运行结果来看，ID被jvm自动分配为：22

name被jvm自动填充为Thread-0

这里值得注意的是，main方法也是一个线程，还是个主线程，而且有着自己独属的名字

就直接命名为main

而后创建的线程从Thread-n开始（这是默认填充名字），n从0开始

状态则显示为TIMED_WAITING

这里简单介绍下这里的几种状态：

状态	含义	例子
NEW	线程被创建但尚未启动	新买的车还没发动。
RUNNABLE	线程正在执行或准备执行	车辆在路上行驶。
BLOCKED	线程等待获取锁	等待电梯开门。
WAITING	线程无限期等待另一个线程执行特定操作	在咖啡店等朋友，不确定他们什么时候到。
TIMED_WAITING	线程等待一段时间后继续执行	在咖啡店等朋友，但只愿意等 10 分钟
TERMINATED	线程已完成执行，不能再次启动	完成购物并离开商店。

从图中可以看到优先级为5

那么此时这个5是什么意思呢？

在Java的优先级中，优先级是一个整数值，范围到MIN_PRIORITY(1)->MAX_PRIORITY(10);

Thread.MIN_PRIORITY: 最低优先级，值为 1。
Thread.NORM_PRIORITY: 默认优先级，值为 5。
Thread.MAX_PRIORITY: 最高优先级，值为 10。

接着看到是否存活，很显然，线程run方法执行的内容是死循环，所以是存在这个线程，即存活

值得注意的是，我们是通过创建线程对象，任何才有通过对象，去创建线程。

那么此时，可能会出现Thread对象存在，但是线程是不存在的了（注意：是不会出现，线程存在，Thread对象不存在的）

比如：1.调用start之前，内核中，还没创建线程呢

2.线程中的run方法执行完毕了，内核中的线程自然就无了，但此时Thread对象，仍然存在

是否被中断，这里的中断内容，后续会讲到。

那么接下来讲讲这个线程的一些核心操作

一些核心操作

1.线程创建

这个前一篇文章已经讲述过了噢，那么接下来仅仅补充下

这个线程创建，即是调用这个start方法，那么值得注意的是，start方法不能启动多次，只能一次，

因为一个Thread对象，对应一个线程，在jvm中。

多次启动后的报错信息：

还有就是，在线程中是可以启动其他线程的，也可以创建其他线程的

不只是在main方法中去创建线程。

2.线程的中断

即是一个线程结束

在java中，这个线程中断结束，是比较温柔的做法，假设B正在运行，那么此时，A想让B结束，

那么A就是想办法，把B的run() 方法运行完即可。

这里有一个简单直接的做法可以演示

public class Demo11 {
    private static boolean isQuit=false;
    public static void main(String[] args) throws InterruptedException {
        //不能写在内部，因为我们下面创建线程任务是使用lambda表达式，写在内部涉及到变量捕获//        boolean isQuit=false;
        Thread t=new Thread(()->{
           while (!isQuit){
               System.out.println("hello world");
               try {
                   Thread.sleep(1000);
               } catch (InterruptedException e) {
                   throw new RuntimeException(e);
               }
           }
        });
        t.start();
        Thread.sleep(2000);
        //在这里影响t线程结束
        isQuit=true;
        System.out.println("t线程结束！");
    }
}

当然，还有一个方法，就是通过Thread.currentThread()获取到当前线程的实例，去判断下是否被中断了

 public static void main(String[] args) throws InterruptedException {
        Thread t=new Thread(()->{
            //获取当前线程的引用
           Thread currentThread=Thread.currentThread();
           //默认为falsewhile (!currentThread.isInterrupted()){
               System.out.println("hello world");
               try {
                   Thread.sleep(1000);
               } catch (InterruptedException e) {
                   System.out.println("catch语句已执行！");
                   break;
//                   throw new RuntimeException(e);
               }
           }
        });
        t.start();
        Thread.sleep(4000);
        //这里来控制t线程结束，调用后，currentThread.isInterrupted()返回true
        t.interrupt();
    }

此时为什么会执行到catch语句的内容呢?

这是因为在主线程中呢，t.interrupt();会让这个中断标志设置为true，一开始为false。

那么此时t线程中的，sleep（）正在休眠，此时会导致sleep（）抛出InterruptedException，此时呢，就会执行到catch语句代码

值得注意的是，sleep（）唤醒后，又会重新设置这个中断标志位，即恢复默认情况

那么此时如若我们呢catch语句没有中断操作，除了它，它还是会继续打印hello world代码。

所以Interrupt方法能够设置标志位，也能唤醒sleep等阻塞方法

而且sleep方法唤醒后，又能清空标志位。

3.线程等待

我们之前讲到，这个操作系统针对多个线程的执行，是一个随机调度，抢占式执行的过程。

那么这个线程等待呢，就是确定两个线程的“结束顺序”

比如A线程中调用B.join(),那么这个意思就是让A线程等待B线程先结束，然后再执行A线程的内容

这个join就是线程等待的关键字。

我们可以使用一个代码来演示下

 public static void main(String[] args) throws InterruptedException {
    Thread t1=new Thread(()->{
        for(int i=0;i<4;i++){
            System.out.println("hello t1");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    });
    Thread t2=new Thread(()->{
        for(int i=0;i<=4;i++){
            System.out.println("hello t2");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    });
    t1.start();
    t2.start();
    t1.join();
    t2.join();

所以运行结果中，可能会带着交替出现的效果。

由于是线程是随机调度的，所以打印结果，有可能使交替出现，也有可能不是。

这里我们使main主线程等待t1、t2线程

那么其实也可以t1等待t2线程，或者也可以t2等待t1，甚至多个线程进行等待

那么刚刚使用的这个是无参版本的，

那么此时这个join有可能就是会出现死等的情况，有时候往往不是一个好选择

所以java这里呢，提供了两个带参数的版本

public void join（long millis）	等待线程结束，最多等待millis毫秒
public void join（long millis，int nanos）	同理，但是提供的精度会更高

所以我们如若使用到这个带参数的版本，这样等预定的时间过后，就会执行其他任务了，而不是死等了。

完~