阿华代码,不是逆风,就是我疯,你们的点赞收藏是我前进最大的动力!!7000字长文,希望本文内容能够帮助到你!
目录
一:创建线程五种方式
方式一:继承Thread类,再实例化
方式二:实现Runnable接口,重写run方法
方式三:匿名内部类写法
方式四:Runnable+匿名内部类
方式五:lambda表达式
二:Thread常见方法
1:Thread方法
2:获取Thread属性的方法
(1)守护进程
(2).setDaemon()方法
①前台/后台线程
②.setDaemon
③结果分析:
(3)isAlive()
(4)start方法和run方法的区别
三:如何提前终止一个线程
1:标志位——isQuit
(1)变量捕获:重点重点重点
(2)lambda复制和传参理解
2:Thread内置变量isinterrupted
(1)isinterrupted本质
(2)sleep清空标志符
(3)解决方式(catch中加代码)
一:创建线程五种方式
方式一:继承Thread类,再实例化
package thread;
/**
* Created with IntelliJ IDEA.
* Description:
* User: Hua YY
* Date: 2024-09-17
* Time: 14:20
*/
class MyThread extends Thread{
@Override
public void run() {
System.out.println("这就是进入该线程的入口");
}
}
public class ThreadDemo1 {
public static void main(String[] args) {
//根据类,创建实例,线程实例才是真正的线程
//一般用向上转型的写法
Thread t = new MyThread();
t.start();
}
}
方式二:实现Runnable接口,重写run方法
package thread;
/**
* Created with IntelliJ IDEA.
* Description:
* User: Hua YY
* Date: 2024-09-19
* Time: 9:20
*/
class MyTread3 implements Runnable{
@Override
public void run() {
while(true){
System.out.println("这里是run线程");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
}
}
public class TreadDome3 {
public static void main(String[] args) {
Runnable runnable = new MyTread3();//相当于借刀杀人了
Thread t = new Thread(runnable);
t.start();
while(true){
System.out.println("这里是main函数线程");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
}
}
注:可以通过Runnable这个接口,可以抽象出一段被其他实体执行的代码,还是需要搭配Thread类来进行使用
方式三:匿名内部类写法
在实例化Thread对象时{}里创建匿名内部类,重写run方法
匿名内部类:
①没有名字,不能重复使用
②这个新的类继承自Thread,并且{}里可以定义子类的属性和方法
③t的指向不仅仅是Thread,还有它的子类(虽然没名字),(即不仅是Thread的实例,也是其子类的实例)
package thread; /** * Created with IntelliJ IDEA. * Description: * User: Hua YY * Date: 2024-09-19 * Time: 9:39 */ public class ThreadDome4 { public static void main(String[] args) { Thread thread = new Thread(){ public void run(){ while(true){ System.out.println("这里是由匿名内部类实现的线程"); try { Thread.sleep(1000); } catch (InterruptedException e) { throw new RuntimeException(e); } } } }; thread.start(); while(true){ System.out.println("这里是main函数入口"); try { Thread.sleep(1000); } catch (InterruptedException e) { throw new RuntimeException(e); } } } }
方式四:Runnable+匿名内部类
实现Runnable接口,重写run方法实现匿名内部类
package thread;
/**
* Created with IntelliJ IDEA.
* Description:
* User: Hua YY
* Date: 2024-09-19
* Time: 10:07
*/
public class ThreadDome5 {
public static void main(String[] args) {
Thread thread = new Thread(new Runnable() {
@Override
public void run() {
while(true){
System.out.println("run method");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
}
});
thread.start();
while(true){
System.out.println("main method");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
}
}
方式五:lambda表达式
lambda表达式,适合简单直观的代码,如果代码过于复杂还是需要提取出来的
在Java中方法的实现依赖于类,方法不能脱离类单独存在,这里就导致为了设置回调函数,不得不套上一层类,但是并不常用——引出了lambda表达式。
函数式接口相当于在没有破坏java原有的规则上(方法不能脱离类单独存在),单独给lambda一个解释
第一个标记的红色方框中的()-> ,()括号中可以带参数
package thread;
/**
* Created with IntelliJ IDEA.
* Description:
* User: Hua YY
* Date: 2024-09-19
* Time: 10:29
*/
public class ThreadDome55 {
public static void main(String[] args) {
Thread thread = new Thread(()->{
while (true){
System.out.println("run method");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
});
thread.start();
while(true){
System.out.println("main method");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
}
}
二:Thread常见方法
1:Thread方法
2:获取Thread属性的方法
后面的代码中会运用到,有相应的解释
(1)守护进程
通过之前的学习,我们知道,main方法走完了,整个进程就结束了。 现在我们引入了线程的概念,那这个结论还准确吗。有没有例外呢?
下面我们举例:代码里面我们创建main函数线程
这里我们使用jconsole工具来辅助(上一篇博客有讲怎么使用jconsole前面)
package thread;
/**
* Created with IntelliJ IDEA.
* Description:
* User: Hua YY
* Date: 2024-09-19
* Time: 10:58
*/
public class ThreadDome6 {
public static void main(String[] args) {
Thread thread = new Thread(new Runnable() {
@Override
public void run() {
while(true){
System.out.println("run method");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
}
} , "这个线程的名字叫:测试");
thread.start();
}
}
我们可以发现jconsole线程运行详细信息中,没有main函数,但是有我们的测试线程,很明显即使main函数这个前台线程已经结束了,但是这个进程依旧还在运行(可以说是这个“这个线程的名字叫:测试”的线程还在运行)
由此我们引出一组概念:前台线程和后台线程
(2).setDaemon()方法
①前台/后台线程
重点:咱们创建的线程,默认都是前台线程,会阻止进程的结束,只要前台线程没有执行完,进程就不会结束,即使main函数这个线程已经执行完毕
(这么理解:后台进程没有话语权,只要还有前台线程,进程就不会结束)
②.setDaemon
理解:Daemon是守护的意思,这个方法是把某线程设置为后台线程(守护线程)
注:这个方法一定要在“.start”方法之前设置
接上文,我们引入.setDaemon()方法,可以将Thread下的线程从前台改为后台,下面会详细解释两者区别。
③结果分析:
什么都没有打印是因为,我们把main函数设置为了后台线程,这个线程走完了,那整个进程都结束了,Thread这个前台线程
(3)isAlive()
isAlive(),方法,表示了当前内核中的线程(pcb)是否还存在,内核中的线程和实例的周期是不一致的
①在创建完Thread对象之后,start方法之前,pcb还没有创建出来,所以答疑结果为false
②在start方法之后,线程结束之前,对象存在,pcb存在,打印结果为true,
③线程run完了,pcb得到释放,为false
④注意下面的代码Thread.sleep(5000) ,如果沉睡时间改为3000ms以下,那么最后一条打印结果就不确定了,线程的随机调度
package thread;
/**
* Created with IntelliJ IDEA.
* Description:
* User: Hua YY
* Date: 2024-09-19
* Time: 18:24
*/
public class ThreadDemon8 {
public static void main(String[] args) throws InterruptedException {
Thread thread = new Thread(()->{
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
});
System.out.println(thread.isAlive());//false,有对象,无pcb线程
thread.start();//创建线程
System.out.println(thread.isAlive());//true,有对象,有pcb
Thread.sleep(5000);//main函数线程沉睡5s,此时Thread线程3s沉睡完了,thread线程结束,thread对象还在
System.out.println(thread.isAlive());//false
}
}
(4)start方法和run方法的区别
start方法核心是创建一个新的线程,但是run方法仅仅是一个方法、一个线程的入口,类似main方法的入口,两者不能说没有关系,简直是毫无关系!!!
package thread;
/**
* Created with IntelliJ IDEA.
* Description:
* User: Hua YY
* Date: 2024-09-19
* Time: 18:56
*/
public class ThreadDemon9 {
public static void main(String[] args) {
Thread t1 = new Thread(){
@Override
public void run() {
while(true){
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
System.out.println("run线程方法正在执行");
}
}
};
//t1.run();//不屏蔽这行代码,将会一直死循环在run方法中,单线程main的
t1.start();
System.out.println("main函数线程正在执行");
}
}
三:如何提前终止一个线程
1:标志位——isQuit
我们需要在Thread实例化中写符合能够控制线程的结构,下面的代码我们引入isQuit这个静态成员变量,来控制while循环,进而达到提前终止线程这样一个目的
/**
* Created with IntelliJ IDEA.
* Description:
* User: Hua YY
* Date: 2024-09-19
* Time: 19:18
*/
public class ThreadDemon12 {
private static boolean isQuit = false;
public static void main(String[] args) throws InterruptedException {
Thread t1 = new Thread(()->{
while(!isQuit){
try {
Thread.sleep(500);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
System.out.println("t1线程正在运行");
}
});
t1.start();
Thread.sleep(2001);
isQuit = true;
System.out.println("终止t1线程");
}
}
(1)变量捕获:重点重点重点
提问:上述代码能否将isQuit这个变量在main方法中定义(局部变量)。不行
在lambda匿名内部类当中有一条规定:lambda匿名内部类可以获取外面定义的成员变量(本质是将外面的成员变量作为参数传进来,这个被捕获的(变量)参数必须是final,或者“事实final”)
大前提这个变量定义在main函数内部
零:解释“事实final”
定义的成员变量虽然没有被final修饰,但是这个成员变量没有被修改过(有点那种“虽无夫妻之名,但有夫妻之实”的感觉)。
举例1:在mian函数内部定义 不加final修饰 的局部变量(可行)
举例2:在mian函数内部定义 不加final修饰 的局部变量 并且修改isQuit的值(不可行,lambda报错)
举例3:在mian函数内部定义 加final修饰 的局部变量 并且修改isQuit的值(不可行,final报错)
(2)lambda复制和传参理解
承接举例1:我们删除isQuit这一行代码
我们都知道,main函数执行完毕,那么main函数中定义的局部变量会进行回收,但是在上述两个线程中,main方法结束了,isQuit已经被回收了,这个Thread(t1)线程为什么还能运行(他线程用到了isQuit作为循环判断条件)。
总结:这里是因为,lambda获得的成员变量,是作为参数传进来的(可以理解为复制拷贝,是一个全新的个体),main方法执行完了,isQuit的栈帧就销毁了,但是Thread(t1)中拷贝过来的isQuit所创建的栈帧还在呀!!!
。
2:Thread内置变量isinterrupted
(1)isinterrupted本质
利用Thread类的实例内部成员变量,来取代我们在1中使用的,手动创建的静态成员变量isQuit
package thread;
/**
* Created with IntelliJ IDEA.
* Description:
* User: Hua YY
* Date: 2024-09-20
* Time: 10:23
*/
public class ThreadDemon13 {
public static void main(String[] args) throws InterruptedException {
Thread t1 = new Thread(()->{
while(!Thread.currentThread().isInterrupted()){ //当t1.interrupt();生效,循环条件为false,被打断了
try {
Thread.sleep(500);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
System.out.println("t1线程正在运行");
}
});
t1.start();
Thread.sleep(2001);
t1.interrupt();//让t1被打断,相当于isQuit = true
System.out.println("终止t1线程");
}
}
(2)sleep清空标志符
结果分析——
目的:给程序员创造更多的“可操作空间”
运行上述代码,报错,这是因为,我们的中断了t1线程的sleep(提前唤醒会做两件事:1:清空标志符,2:抛出InterruptedException异常),sleep把interrupted又设置回false,进而while循环判定条件变成true,最后被catch捕获中断异常。
(3)解决方式(catch中加代码)
①让线程立即结束:加上break;
②让线程不结束:不加break,让它报错
③让线程执行一些代码后再结束:写一些其它代码后,再break。