目录
1.Tread类介绍
2线程的构造方法——创建线程
1.继承Thread类,重写run()方法
2.使用Runnbable接口创建线程
3.继承 Thread, 重写 run, 使用匿名内部类
4.实现 Runnable, 重写 run, 使用匿名内部类
5.使用 lambda 表达式(重点掌握)
3.Tread类常见方法解读
3.1Tread类常见构造方法
3.2 Tread类的几个常见属性
3.3启动一个线程-start()方法
3.4中断一个线程
3.5等待一个线程-join()
3.6休眠线程
3.7 实现一个简单的多线程
4.线程的状态
4.1线程的六种状态
4.2线程状态和状态转移
1.Tread类介绍
Thread 类是 JVM 用来管理线程的一个类,换句话说,每个线程都有一个唯一的 Thread 对象与之关联,每个执行流(线程),也需要有一个对象来描述, Thread 类的对象就是用来描述一个线程执行流的,JVM 会将这些 Thread 对象组织起来,用于线程调度、线程管理。
2线程的构造方法——创建线程
无论使用哪一个方法创建线程,我们都需要将其中的run方法重写(run方法中写入的是线程需要执行的任务),它的作用就相当于主线程的main方法。
1.继承Thread类,重写run()方法
这个构造方法没有参数,通过创造一个类继承Thread类来实现线程 ,线程必须重写run()方法才算完成。当我们new一个线程时,此时的线程还没开始执行,再用创建的类调用start()方法才算运行了这个线程。
class TestTread extends Thread{
@Override
public void run() {
System.out.println("this tread1");
}
}
public class testDemo2 {
public static void main(String[] args) {
Thread thread=new TestTread();
thread.start();
}
}
2.使用Runnbable接口创建线程
我们可以看出,该构造方法的参数类型是一个接口类,因此我们需要创建一个类来实现这个接口,再new一个实现Runnable的类对象,再new一个线程,将之前创建的对象放入到参数这里。
class TestTread2 implements Runnable {
@Override
public void run() {
System.out.println("this t2");
}
}
public class testDemo2 {
public static void main(String[] args) {
//new一个实现Runnable接口的对象
TestTread2 testTread2=new TestTread2();
//传入参数完成线程的创建
Thread t2=new Thread(testTread2);
t2.start();
}
}
3.继承 Thread, 重写 run, 使用匿名内部类
使用匿名内部类可以省略创建对象的过程,可以减少资源消耗。
public class testDemo3 {
public static void main(String[] args) {
//通过Thread匿名内部类的方法创建一个线程
Thread t1=new Thread() {
@Override
public void run() {
System.out.println("this t1");
}
};
t1.start();
}
}
4.实现 Runnable, 重写 run, 使用匿名内部类
这个和3一样,可以少创建一个对象,减少资源的消耗。
public class testDemo4 {
public static void main(String[] args) {
Thread t1=new Thread(new Runnable() {
@Override
public void run() {
System.out.println("this t1");
}
});
t1.start();
}
}
5.使用 lambda 表达式(重点掌握)
它的实现原理和匿名内部类相似,这点不了解lambda表达式的,可以去看一下如何使用。
public class testDemo4 {
public static void main(String[] args)
Thread t2=new Thread(()->{
System.out.println("this t2");
});
t2.start();
}
}
3.Tread类常见方法解读
3.1Tread类常见构造方法
方法 | 说明 |
Thread() | 创建线程对象 |
Thread(Runnable target) | 使用 Runnable 对象创建线程对象 |
Thread(String name) | 创建线程对象,并命名 |
Thread(Runnable target, String name) | 使用 Runnable 对象创建线程对象,并命名 |
【了解】Thread(ThreadGroup group, Runnable target) |
线程可以被用来分组管理,分好的组即为线程组,这 个目前我们了解即可 |
3.2 Tread类的几个常见属性
属性 | 获取方法 |
ID | getId() |
名称 | getName() |
状态 | getState() |
优先级 | getPriority() |
是否后台线程 | isDaemon() |
是否存活 | isAlive() |
是否被中断 | isInterrupted() |
- ID 是线程的唯一标识,不同线程不会重复。
- 名称是各种调试工具用到。
- 状态表示线程当前所处的一个情况,下面我们会进一步说明。
- 优先级高的线程理论上来说更容易被调度到。
- 关于后台线程,需要记住一点:JVM会在一个进程的所有非后台线程结束后,才会结束运行。
- 是否存活,即简单的理解,为 run 方法是否运行结束了。
- 线程的中断问题,下方会有解析
3.3启动一个线程-start()方法
调用 start 方法, 才算是在操作系统的底层创建出一个线程.
public class testDemo4 {
public static void main(String[] args) {
Thread t1=new Thread(new Runnable() {
@Override
public void run() {
System.out.println("this t1");
}
});
t1.start();
}
}
3.4中断一个线程
方法 | 说明 |
public void interrupt() | 中断对象关联的线程,如果线程正在阻塞,则以异常方式通知, 否则设置标志位 |
public static boolean interrupted() |
判断当前线程的中断标志位是否设置,调用后清除标志位 |
public boolean isInterrupted() |
判断对象关联的线程的标志位是否设置,调用后不清除标志位 |
- 使用 thread 对象的 interrupted() 方法通知线程结束
public class testDemo6 {
public static void main(String[] args) throws InterruptedException {
Thread t1=new Thread(() ->{
while (!Thread.interrupted()) {
System.out.println(Thread.currentThread().getName());
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
break;
}
}
});
t1.start();
Thread.sleep(1000*2);
t1.interrupt();
}
}
t1收到通知的方式有两种:
1.如果线程因为调用 wait/join/sleep 等方法而阻塞挂起,则以 InterruptedException 异常的形式通知,清除中断标志.
- 当出现 InterruptedException 的时候, 要不要结束线程取决于 catch 中代码的写法. 可以选择忽略这个异常, 也可以跳出循环结束线程(加break).
2.否则,只是内部的一个中断标志被设置,thread 可以通过
- Thread.interrupted() 判断当前线程的中断标志被设置,清除中断标志
- Thread.currentThread().isInterrupted() 判断指定线程的中断标志被设置,不清除中断标志
- 使用 Thread.isInterrupted() , 线程中断会清除标志位
标志位是否清除, 就类似于一个开关.
Thread.Interrupted() 相当于按下开关, 开关自动弹起来了. 这个称为 "清除标志位".
public class ThreadDemo {
public static void main(String[] args) throws InterruptedException {
Thread thread = new Thread(()->{
for (int i = 0; i < 10; i++) {
// //打印标准位
System.out.println(Thread.interrupted());
}
});
thread.start();
thread.interrupt();
}
}
结果:
观察结果可以看出,已知interrupted()初始是true,之后就打印的值就是false,因为标志位已经被删除了。
- 使用 Thread.currentThread().isInterrupted() , 线程中断标记位不会清除
标志位是否清除, 就类似于一个开关.
Thread.currentThread().isInterrupted() 相当于按下开关之后, 开关弹不起来, 这个称为"不清除标志位".
public class ThreadDemo {
public static void main(String[] args) throws InterruptedException {
Thread thread = new Thread(()->{
for (int i = 0; i < 10; i++) {
// //打印标准位
System.out.println(Thread.currentThread().isInterrupted());
}
});
thread.start();
thread.interrupt();
}
}
结果:
观察结果可以清晰的看出,打印的全是true,这是因为标志位没有被删除,它的值还是true。
3.5等待一个线程-join()
方法 | 说明 |
public void join() | 等待线程结束 |
public void join(long millis) | 等待线程结束,最多等 millis 毫秒 |
public void join(long millis, int nanos) | 同理,但可以更高精度 |
public class testDemo7 {
public static void main(String[] args) throws InterruptedException {
Thread t1=new Thread(()->{
for (int i = 0; i < 10; i++) {
System.out.println("第"+i+"次打印"+Thread.currentThread().getName());
}
System.out.println("----------");
});
Thread t2=new Thread(()->{
for (int i = 0; i < 10; i++) {
System.out.println("第"+i+"次打印"+Thread.currentThread().getName());
}
});
t1.start();
//t2等待t1执行完毕,t2才可执行
t1.join();
t2.start();
}
}
结果:
可以看出使用了join(),两个线程不再是杂乱运行了,而是先运行完t1线程,再运行的t2线程。这就是join 的作用。
3.6休眠线程
这个是比较熟悉一组方法,有一点要记得,因为线程的调度是不可控的,所以,这个方法只能保证实际休眠时间是大于等于参数设置的休眠时间的。
方法 | 说明 |
public static void sleep(long millis) throws InterruptedException | 休眠当前线程 millis 毫秒 |
public static void sleep(long millis, int nanos) throws InterruptedException |
可以更高精度的休眠 |
3.7 实现一个简单的多线程
这两个线程任务都是打印自己的名字,其中使用的currentThread()方法是或者当前线程的引用,getName()方法就是或者线程的名字(就算我们没有给线程起名字,系统也会给它自定义一个名字)。
public class testDemo5 {
public static void main(String[] args) {
Thread t1=new Thread(()->{
while (true) {
//打印线程名称
System.out.println(Thread.currentThread().getName());
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
Thread t2=new Thread(()->{
while (true){
//打印线程名称
System.out.println(Thread.currentThread().getName());
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
//执行线程任务
t1.start();
t2.start();
}
}
代码实现结果:
观察可以看出,两个线程是交叉运行,并且是杂乱运行,好不规律可言。没错,线程的并发就是没有规律的,谁先运行取决于操作系统如何调度线程,因此线程是"抢占式执行"。
4.线程的状态
4.1线程的六种状态
- NEW: 安排了工作, 还未开始行动,刚刚创建一个Tread对象,还没开始工作。
- RUNNABLE: 可工作的. 又可以分成正在工作中和即将开始工作(正在CPU上执行任务或者在就绪队列中随时可以在CPU上执行的)。
- BLOCKED: 这几个都表示排队等着其他事情(synchronized加锁)。
- WAITING: 这几个都表示排队等着其他事情。
- TIMED_WAITING: 这几个都表示排队等着其他事情(使用sleep或者join方法引起的)。
- TERMINATED: 工作完成了。
4.2线程状态和状态转移
举个例子,看下图:文章来源:https://www.toymoban.com/news/detail-401098.html
文章来源地址https://www.toymoban.com/news/detail-401098.html
到了这里,关于【JavaEE】线程的创建及常见方法解析(Tread类)的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!