线程的声明方式和生命周期
线程创建的二种方式
- 继承Thread类
package com.ys.thread;
class Thread1 extends Thread{
@Override
public void run() {
for(int i = 0 ; i < 10 ;i++){
System.out.println("播放音乐"+i);
}
}
}
public class ThreadTest {
public static void main(String[] args) {
for(int i = 0 ; i < 10 ; i++){
System.out.println("玩游戏"+i);
if(i==5){
Thread1 th1 = new Thread1();
th1.start();
}
}
}
}
- 实现Runnable接口
class Runnable1 implements Runnable{
@Override
public void run() {
for(int i = 0 ; i < 10 ;i++){
System.out.println("播放音乐"+i);
}
}
}
public class RunnableTest {
public static void main(String[] args) {
for(int i = 0 ; i < 10 ; i++){
System.out.println("玩游戏"+i);
if(i==5){
Thread th1 = new Thread(new Runnable1());
th1.start();
}
}
}
}
3.使用匿名内部类创建对象
public static void main(String[] args) {
for(int i = 0 ; i < 10 ; i++){
System.out.println("玩游戏"+i);
if(i==5){
new Thread(new Runnable() {
@Override
public void run() {
for(int i = 0 ; i < 10 ;i++){
System.out.println("播放音乐"+i);
}
}
}).start();
}
}
}
注意:
1、启动线程是调用 start() 方法,而不是 调用 run() 方法。
解析:run()方法:在本线程内调用run()方法,和其他方法没有什么区别,可以重复多次调用;
start()方法:启动一个线程,实际上还是调用该Runnable对象的run()方法。
打开 Thread 类的源码,start()方法里面有一句
private native void start0();
//native 关键字:本地程序调用
native关键字指的是Java本地接口调用,即是使用Java调用本地操作系统的函数功能完成一些特殊的操作,而这样的代码开发在Java中几乎很少出现,因为Java的最大特点是可移植性,如果一个程序
只能在固定的操作系统上使用,那么可移植性就将彻底丧失,多线程的实现一定需要操作系统的支持,那么start0()方法实际上就和抽象方法很类似,没有方法体,而是交给JVM
去实现,即在windows下的JVM可能使用A方法实现start0(),在linux下的JVM可能使用B方法实现start0(),在调用时并不会关心具体是何方式实现了start0()方法,只会关心最终的操作结果,交给
JVM去匹配了不同的操作系统。
2、不能多次启动同一个线程,即多次调用 start() 方法,只能调用一次,否则报错:
线程的生命周期
1、新建状态(new):使用 new 创建一个线程,仅仅只是在堆中分配了内存空间
新建状态下,线程还没有调用 start()方法启动,只是存在一个线程对象而已
Thread t = new Thread();//这就是t线程的新建状态
2、可运行状态(runnable):新建状态调用 start() 方法,进入可运行状态。而这个又分成两种状态,ready 和 running,分别表示就绪状态和运行状态
就绪状态:线程对象调用了 start() 方法,等待 JVM 的调度,(此时该线程并没有运行)
运行状态:线程对象获得 JVM 调度,如果存在多个 CPU,那么运行多个线程并行运行
注意:线程对象只能调用一次 start() 方法,否则报错:illegaThreadStateExecptiong
3、阻塞状态(blocked):正在运行的线程因为某种原因放弃 CPU,暂时停止运行,就会进入阻塞状态。此时 JVM 不会给线程分配 CPU,知道线程重新进入就绪状态,才有机会转到 运行状态。
注意:阻塞状态只能先进入就绪状态,不能直接进入运行状态
阻塞状态分为两种情况:
①、当线程 A 处于可运行状态中,试图获取同步锁时,却被 B 线程获取,此时 JVM 把当前 A 线程放入锁池中,A线程进入阻塞状态
②、当线程处于运行状态时,发出了 IO 请求,此时进入阻塞状态
4、等待状态(waiting):等待状态只能被其他线程唤醒,此时使用的是无参数的 wait() 方法
①、当线程处于运行状态时,调用了 wait() 方法,此时 JVM 把该线程放入等待池中
5、计时等待(timed waiting):调用了带参数的 wait(long time)或 sleep(long time) 方法
①、当线程处于运行状态时,调用了带参数 wait 方法,此时 JVM 把该线程放入等待池中
②、当前线程调用了 sleep(long time) 方法
6、终止状态(terminated):通常称为死亡状态,表示线程终止
①、正常终止,执行完 run() 方法,正常结束
②、强制终止,如调用 stop() 方法或 destory() 方法
③、异常终止,执行过程中发生异常
下面详细介绍线程的几种方法:
1、sleep(long millis)线程休眠:让执行的线程暂停一段时间,进入计时等待状态。
static void sleep(long millis):调用此方法后,当前线程放弃 CPU 资源,在指定的时间内,sleep 所在的线程不会获得可运行的机会,此状态下的线程不会释放同步锁(注意和 wait() 的区别,wait 会放弃 CPU 资源,同时也会放弃 同步锁)
该方法更多的是用来模拟网络延迟,让多线程并发访问同一资源时的错误效果更加明显。
2、join()联合线程:表示这个线程等待另一个线程完成后(死亡)才执行,join 方法被调用之后,线程对象处于阻塞状态。写在哪个线程中,哪个线程阻塞
这种也称为联合线程,就是说把当前线程和当前线程所在的线程联合成一个线程
package com.ys.thread;
class Join extends Thread{
@Override
public void run() {
for(int i = 0 ; i < 10 ;i++){
System.out.println("播放音乐"+i);
}
}
}
public class ThreadTest {
public static void main(String[] args) {
//创建 join 线程对象
Join joinThread = new Join();
for(int i = 0 ; i < 10 ; i++){
System.out.println("玩游戏"+i);
if(i==3){
joinThread.start();
}
if(i==5){
try {
joinThread.join();//强制运行 join 线程,知道 join 运行完毕了,main 才有机会运行
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}