那里有网站建设,网站建设实习业务介绍,如何做网络推广推广,vps免费找往期文章包括但不限于本期文章中不懂的知识点#xff1a; 个人主页#xff1a;我要学编程(ಥ_ಥ)-CSDN博客 所属专栏#xff1a;JavaEE 目录
创建线程
1、继承 Thread类
2、实现Runnable接口
3、使用匿名内部类
1#xff09;继承Thread类的匿名内部类
2#xff09… 找往期文章包括但不限于本期文章中不懂的知识点 个人主页我要学编程(ಥ_ಥ)-CSDN博客 所属专栏JavaEE 目录
创建线程
1、继承 Thread类
2、实现Runnable接口
3、使用匿名内部类
1继承Thread类的匿名内部类
2实现Runnable接口
查看线程的状态
Thread类的常见属性与方法 创建线程
Thread 是线程的意思在Java中也是通过 Thread类中的 start 方法启动一个线程。但要注意的是每一个线程对象都只能调用一次 start方法如果后续再去调用的话便会抛异常。
在Java中有四种方式实现多线程。
1、继承 Thread类
语法格式
// 继承Thread类
class MyThread extends Thread {Overridepublic void run() {....... // 代码}
}public class Test {public static void main(String[] args) {Thread t new MyThread();// 启动 t线程调用run方法t.start();// 后续代码.......}
} 我们创建一个新的类使其继承Thread类并重写其中的run方法。这就已经具备了一个线程的基本雏形现在只要我们在main线程中去实例化这个类并且启动这个线程即可。启动线程的方法是通过调用线程对象的start方法start方法会启动一个新的线程并在这个新线程中自动调用run方法完成该线程的所执行的任务。
// 1、继承Thread类
class MyThread extends Thread {Overridepublic void run() { // 重写run方法while (true) {System.out.println(Hello Thread);}}
}public class Test {public static void main(String[] args) {Thread t new MyThread();// 启动 t线程调用run方法t.start(); // 这里发生了多态while (true) {System.out.println(Hello main);}}
}上述代码运行后会出现 Hello main 和 Hello Thread 循环交替的打印这便是多线程。main线程在运行的同时t 线程也在运行。 从结果上也能看出这是在并发执行main线程在CPU上运行一段时间t 线程接着在CPU上运行一段时间。 我们可以使用 sleep 方法来放慢观察。与C语言中的sleep函数一样是让程序休眠的方法。下面就来详细介绍一下
Java中的sleep方法是Thread类的一个静态方法参数是要休眠时间单位是毫秒。我们可以先写一个代码来演示
public class Test {public static void main(String[] args) throws InterruptedException {while (true) {System.out.println(Hello main);Thread.sleep(1000); // 会抛异常需要throws或者try-catch}}
}上面的代码会打印一个 Hello main 之后休眠1000毫秒即1秒。 注意这个休眠是让线程主动的放弃CPU资源。
现在我们可以近距离观察多线程的运行情况了。
// 1、继承Thread类
class MyThread extends Thread {Overridepublic void run() {while (true) {System.out.println(Hello Thread);try {Thread.sleep(1000);} catch (InterruptedException e) {throw new RuntimeException(e);}}}
}public class Test {public static void main(String[] args) throws InterruptedException {Thread t new MyThread();// 启动 t线程调用run方法t.start(); // 这里发生了多态while (true) {System.out.println(Hello main);Thread.sleep(1000);}}
}
运行结果 有细心的小伙伴应该发现了使用sleep方法时 run方法和main方法中的处理方式不一样run方法是通过try-catch的形式而main方法中两种都是可以的。这是因为run方法是重写了Thread类中的run方法父类的没有throws这个操作因此子类在重写时也不能有throws操作不然就会改变run方法的框架从而不符合重写的概念。
2、实现Runnable接口
// 实现Runnable接口
class MyRunnable implements Runnable {Overridepublic void run() {....... // 代码}
}public class Test {public static void main(String[] args) {Thread t new Thread(new MyRunnable());// 启动 t线程并调用run方法t.start();// 后续代码}
}
我们创建一个新的类实现 Runnable接口重写 run方法。接着在main方法中将实例化一个Thread类对象将 实现Runnable接口的类实例化作为参数传入Thread中。
代码演示
class MyRunnable implements Runnable {Overridepublic void run() {while (true) {System.out.println(Hello Thread);try {Thread.sleep(1000);} catch (InterruptedException e) {throw new RuntimeException(e);}}}
}public class Test {public static void main(String[] args) throws InterruptedException {Thread t new Thread(new MyRunnable());// 启动 t线程调用run方法t.start();while (true) {System.out.println(Hello main);Thread.sleep(1000);}}
}运行结果 注意我们使用t.run方法也能执行代码但是得不到 t.start的效果。因为t.run方法不会创建线程只是一个简单的方法调用那么最终代码就会一直死循环打印 Hello Thread。如下所示 使用 t.start 时是先创建的线程然后再去调用的run方法因此 t 线程和main线程会并发执行。
上面是两种主要的创建线程的方式剩下的两种就是通过对上面的变形来编写的。
3、使用匿名内部类
使用匿名内部类有两种选择一个是继承Thread类一个是实现Runnable接口
1继承Thread类的匿名内部类
public class Test {public static void main(String[] args) throws InterruptedException {Thread t new Thread(){Overridepublic void run() {while (true) {System.out.println(Hello Thread);try {Thread.sleep(1000);} catch (InterruptedException e) {throw new RuntimeException(e);}}}};// 启动 t线程调用run方法t.start();while (true) {System.out.println(Hello main);Thread.sleep(1000);}}
}当然除了上面这种写法还有另一种写法
public class Test {public static void main(String[] args) throws InterruptedException {new Thread(){Overridepublic void run() {while (true) {System.out.println(Hello Thread);try {Thread.sleep(1000);} catch (InterruptedException e) {throw new RuntimeException(e);}}}}.start(); // 这里启动了线程并调用了run方法while (true) {System.out.println(Hello main);Thread.sleep(1000);}}
}第一种写法是通过父类引用来接收子类对象而第二种写法就是一次性的线程当这次使用完成之后后续再也不能使用该线程了。
2实现Runnable接口
public class Test {public static void main(String[] args) throws InterruptedException {Thread t new Thread(// 创建一个匿名对象该对象是实现了Runnable接口的匿名内部类new Runnable() {Overridepublic void run() {while (true) {System.out.println(Hello Thread);try {Thread.sleep(1000);} catch (InterruptedException e) {throw new RuntimeException(e);}}}});// 启动 t线程并调用run方法t.start();while (true) {System.out.println(Hello main);Thread.sleep(1000);}}
}由于 Runnable 接口是函数式接口一个接口中只包含一个抽象方法因此我们可以使用lambda表达式来简写。
public class Test {public static void main(String[] args) throws InterruptedException {Thread t new Thread(()-{while (true) {System.out.println(Hello Thread);try {Thread.sleep(1000);} catch (InterruptedException e) {throw new RuntimeException(e);}}});// 启动 t线程并调用run方法t.start();while (true) {System.out.println(Hello main);Thread.sleep(1000);}}
}lambda表达式() 这个要重写的方法的参数 - 是必不可少的{} 这里面是要重写的方法的方法体即具体的代码。
以上就是创建线程的全部方法了。
我们在日常的开发中使用最多的就是通过实现 Runnable 接口来创建线程。因为我们在使用 Runnable 接口创建线程时是将实现该接口的对象作为参数传入这样后续如果要修改代码的话也只需要在实现该接口的内部进行修改而不需要再去改动main线程中的代码了。这样代码之间的依赖程度就降低了而是通过模块来之间来依赖维护也就达到了高内聚、低耦合的效果。而使用 lambda 表达式来简写代码的方式则是既方便可读性也不差。因此我们基本上是使用 lambda 表达式来简写实现 Runnable 接口来创建线程。
查看线程的状态
我们可以通过JDK自带的工具来查看当前进程的状态以及具体线程的相关状态。
1、找到安装JDK的目录。
2、找到bin目录下的 jconsole 这个.exe文件并双击运行。
3、找到要连接的进程一般对应的类名然后点击连接即可。下图是双击运行后的界面 以上就是关于如果查看线程相相关信息的操作。
Thread类的常见属性与方法
上面我们是采用了Thread类的两种构造方法来创建线程的其实除了上面的方法外还有其他的几种构造方法。
方法描述Thread()创建线程对象Thread(Runnable target)使用Runnable对象创建线程对象Thread(String name)创建线程对象并命名Thread(Runnable target, String name)使用 Runnable 对象创建线程对象并命名Thread(ThreadGroup group, Runnable target)这个暂时不需要用到后期再学习
注意使用 Thread() 和 Thrad(String name)这两个方法都是要重写 run 方法的而另外两个虽然使用 Runnable但本质上还是要重写 run 方法。因此对于一个线程最重要的就是 run方法虽然 start 方法是启动线程但是只要 run 方法执行完毕通常这个线程就会被销毁。
下面就来学习线程的常见属性
属性获取方法IDgetld()名称getName()状态getState()优先级getPriority()是否后台线程守护线程isDaemon()是否存活isAlive()是否被中断islnterrupted()
解释
1、ID 是线程的唯一标识、名称是各种调试工具用到、状态表示线程当前所处的一个情况就绪态、阻塞态、运行态等。
2、优先级是指当多个线程同时被调度时由于是随机调度的不能确保某个线程一定会被第一时间执行但如果某个线程的优先级比较高的话那么就会先运行该线程。
3、后台线程也叫作守护线程即这个线程只是默默守护 并不会干扰到程序的正常运行当程序正常运行结束后进程结束了后台线程也就被销毁了但是前台线程不一样只有当全部的前台线程运行结束后进程才会结束。简单理解就是后台线程不能干预进程的结束而前台线程可以干预进程的结束。
从上面我们查看线程的状态那里可以看出来我们自己创建的线程默认都是前台线程。我们也可以通过代码来观察
public class Test {public static void main(String[] args) throws InterruptedException {Thread t new Thread(()-{while (true) {System.out.println(Hello Thread);try {Thread.sleep(1000);} catch (InterruptedException e) {throw new RuntimeException(e);}}});// 设置成后台线程t.setDaemon(true);// 启动 t线程并调用run方法t.start();for (int i 0; i 3; i) {System.out.println(Hello main);Thread.sleep(1000);}System.out.println(main线程结束进程也就结束了);}
}运行结果 注意设置线程的属性一定要在调用start方法之前因为一旦调用start方法之后线程启动了那么就是按照其默认的属性来进行运行了则最终不会停下来。
4、线程是否存活简单理解就是看run方法是否执行完毕但有些特殊情况下即使run方法执行完毕线程依旧存活。
我们也是可以通过代码来观察的。
public class Test {public static void main(String[] args) throws InterruptedException {Thread t new Thread(()-{System.out.println(Hello Thread);System.out.println(t线程结束);});// 看看线程启动前是否存活System.out.println(t.isAlive());t.setDaemon(true);// 启动 t线程并调用run方法t.start();// 看看结束前是否存活System.out.println(t.isAlive());// 确保 t线程已经结束了Thread.sleep(1000);// 看看结束后是否存活System.out.println(t.isAlive());System.out.println(main线程结束进程结束);}
}运行结果 从运行的结果我们可以看出启动前、结束后线程都已经灭亡了当线程还在执行run方法时线程就是存活的。
5、线程的中断就是让线程结束而让线程结束就只有一个办法让 run方法提前结束而让run方法提前就是让while循环提前结束即在while循环的条件语句中来判断。
我们可以用代码来演示
public class Test {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) {throw new RuntimeException(e);}}System.out.println(t线程结束);});// 启动 t线程并调用run方法t.start();Thread.sleep(3000);// 中断t.interrupt();System.out.println(main线程结束);}
}运行结果 首先来解读代码
1、因为 t 在lambda表达式之后才才会创建因此我们在调用 isInterrupted 方法时不能通过 t 来调用要通过 Thread.currentThread 方法来获取当前的类对应的对象然后再用这个对象去调用 isInterrupted 方法。
2、Thread.currentThread().isInterrupted() 方法会返回 false 因为线程在执行的过程中是处于非中断的状态因此我们要对其进行 取反操作才能使其进入while循环。
3、 当我们编写 t.interrupt() 的代码时线程确实会中断但是由于 打印语句的执行是非常快的因此在 t 线程的生命周期中绝大部分时间是处于休眠状态而此方法会唤醒sleep使其抛出异常因此只要我们在 throw 异常的代码中使用break 或者 啥也不做那么就不会抛出异常。 上述是使用 break的效果但如果我们 啥也不干的话发现不会停下来。 其实是 sleep 在捣乱。正常来说调用 Interrupt 方法将 isInterrupted 方法内部的标志位设置为了 true 但由于上述代码中把 sleep 给唤醒了这种提前唤醒的情况下sleep 就会在唤醒之后把 islnterrupted 标志位给设置回 false。所以后续在进行判断的时候还是会进入while循环。
好啦本期 初始JavaEE篇——多线程1Thread类的介绍与使用 的学习之旅到此结束啦我们下一期再一起学习吧
