文章目录
- 一、Thread 类中的常见构造方法
- 二、Thread 的一些常见属性
- 三、线程的启动——start()
- isAlive() 方法的解释
- 四、线程中断
- 五、线程等待-join()了解
- 六、简单解释线程休眠
一、Thread 类中的常见构造方法
我们已知，Thread 类是Java中多线程中的一个关键类，因此我们需要知道其较为常用的构造方法，如下图：
Thread t1 = new Thread(); //创建一个线程对象
Thread t2 = new Thread(Runnable()); //实现Runnable接口中的方法
Thread t3 = new Thread(String name); //创建线程对象并且命名
Thread t4 = new Thread(Runnable(),String name); //使用Runnable 接口实现线程对象并且重命名
简单实现最后一种形式的代码：
public class ThreadDemo {
public static void main(String[] args) {
Thread t = new Thread(new Runnable(){
public void run(){
while(true){
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("hello");
}
}
},"myThread");
t.start();
}
}
运行程序，打卡我们的 jconsole 找到我们的 ThreadDemo 线程，连接后就会找到我们自己命名的线程，如下图：
二、Thread 的一些常见属性
- ID 是线程的唯一标识，每一个线程都有对应的id
- 名称 是指在构造方法中自己起的名称，调试时使用
- 状态 状态标识线程当前所处的一种情况
- 优先级 可以用该方法来获取设置优先级，优先级较高的理论上更容易被调度（其实用处不大）
- 是否后台线程 对于后台线程，JVM 会在一个进程的所有非后台线程结束后，才会结束运行。
前台线程：会阻止进程的结束，前台线程的工作未完成，进程就不会结束。
后台线程：不会阻止进程的结束，后台线程如果未完成，而前台线程完成，进程依然可以照常结束。 - 是否存活：简单理解，就是指“run”方法是否结束。
代码解释后台线程
public static void main(String[] args) {
Thread t = new Thread(()->{
while(true){
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("hello");
}
});
//将线程设定为后台线程
t.setDaemon(true);
t.start();
System.out.println("main");
//判断 t 线程是否为后台线程
System.out.println("t线程是否为后台线程："+t.isDaemon());
}
三、线程的启动——start()
到目前为止，我们已知可以通过重写 run 方法来创建一个线程对象，但是，线程对象的创建并不意味着线程就可以开始运行。
因此，我通过下面的一个图示来给大家详细解释其中原因：
isAlive() 方法的解释
通过上面的解释我们不难理解，线程的存在与否和线程的开始与否有着密切的关系。
因此，我们可以大致进行设想会出现下面的情况：
- 在 start() 方法前，线程不存在显示 false
- 在线程运行中，线程正在进行显示 true
- 在线程任务结束后显示 false
有了以上的设想，我们就可以通过编写相应的代码进行验证：
public static void main(String[] args) {
Thread t = new Thread(()->{
try {
//设置线程等待，延长线程时间
Thread.sleep(100);
System.out.println("hello Thread!");
} catch (InterruptedException e) {
e.printStackTrace();
}
});
//start 方法之前，对线程判断
System.out.println(t.isAlive());
t.start();
//start 后，线程运行中，对线程判断
System.out.println(t.isAlive());
try {
Thread.sleep(200);
} catch (InterruptedException e) {
e.printStackTrace();
}
// 通过等待，线程运行完毕
System.out.println(t.isAlive());
}
运行截图如下：
这里我实现了设想的三种情况，不难发现符合预期。
总结： 只有调用了 start 方法线程才算正真的从操作系统的底层中被创建出来！
四、线程中断
所谓线程中断，顾名思义，就是让线程在正常运行时因为某些原因需要让其暂停运转，但是，这里的中断，并不是表示让线程立即停止，而只是通知线程，你应该停止了。至于线程是否停止，这取决于代码本身的写法！
- 通过程序员自己设置标志位来终止代码
代码实现：
private static boolean flag = true;
public static void main(String[] args) throws InterruptedException {
//中断一个线程
Thread t = new Thread(() -> {
while(flag){
System.out.println("hello thread");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
t.start();
Thread.sleep(3000);
//在主线程里就可以随时通过 flag 变量的取值，来操作 t 线程是否结束
flag = false;
}
这里的代码就可以解释要让一个线程停止，什么时候停止，全部都是由代码内部来实现的。
注：但是，这种方法存在很大的缺陷，在我们运行代码时就会发现，程序停止时中间会有一个很大的空档期，这就说明自定义变量这种方式反应较慢，尤其是在 sleep 时间较长时，不能做到及时响应。
- 使用 Thread 自带的标志位来终止代码
- 使用 Thread 对象中的 interrupted() 方法来通知线程的结束
代码展示：
public static void main(String[] args) throws InterruptedException {
Thread t = new Thread(() -> {
//1.while中的语句需要注意
while(!Thread.currentThread().isInterrupted()){
System.out.println("hello thread");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
t.start();
Thread.sleep(3000);
//2.调用 interrupt 方法告知程序应该结束了
t.interrupt();
}
解释 while 语句中的代码，如图：
解释 2 处的引用：
即，就是重新设定 Boolean 变量告知线程应该停止。
对于代码整体的运行逻辑进行解释
其实不难发现，这种方法就是将第一种 自定义标志位 的 boolean 操作封装到 Thread 的一个类当中了。
运行结果：
如图所示，我们不难发现，这段代码直接印证了 线程中断，并不是让线程立即停止，而是告诉线程应该停止了 这句话。
到此，我们需要知道 interrupt 会做以下两件事：
- 将线程内 标志位(boolean) 给设置成 true。
- 如果线程正在进行 sleep ，此时就会触发异常，将 sleep 唤醒。
但是，sleep 在唤醒的时候，会将刚才设置的标志位再设定位 false（即，清空标志位）
所以通过以上两点，我们可以更加明确地知道为何在 sleep 报错后，循环仍在继续！
自己设定让线程相应终止请求
public static void main(String[] args) throws InterruptedException {
Thread t = new Thread(() -> {
while(!Thread.currentThread().isInterrupted()){
System.out.println("hello thread");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
//要实现线程的及时响应，只需要添加 break 即可
//此处可以根据需要添加任意的代码
break;
}
}
});
t.start();
Thread.sleep(3000);
t.interrupt();
}
五、线程等待-join()了解
在生活中，我们在协同作业的时候常常会遇到等待同伴的情况，线程中也是如此，因此我们也需要一些相应方法来满足需求。
join 的部分相关方法与说明
代码示例：
public static void main(String[] args) throws InterruptedException {
Thread t = new Thread(()->{
for (int i = 0; i < 3; i++) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
// getname()获取自己起的名称
System.out.println(Thread.currentThread().getName()+"正在工作");
}
});
Thread t1 = new Thread(t,"李四");
Thread t2 = new Thread(t,"张三");
t1.start();
// 让 t1 先执行，主线程 main 先等待
t1.join();
System.out.println("李四完成工作，张三开始");
t2.start();
//让 t2 先执行，主线程 main 先等待
t2.join();
System.out.println("张三完成任务");
}
运行结果
六、简单解释线程休眠
通过前面的许多代码，我相信大家对 sleep() 这个方法的使用并不陌生，下面，我就深入到操作系统内核中来给大家解释一下，线程休眠到底是如何运行做的。
所谓线程休眠，即，就是让此线程不参与调度，不到 CPU 上执行。
相关解释如下图：
需要注意的是，虽然 sleep 方法设定了阻塞时间，但是实际情况要比设定的时间间隔大，因为需要考虑到唤醒后调度的开销，因为对应的线程在唤醒后是无法在第一时间就被调用到 CPU 上执行的！
到此, 文章结束, 如有不足, 欢迎提出. 如有错误, 欢迎指正!
