文章目录
一、常用方法
function_name | static | 功能说明 | 注意 |
---|---|---|---|
start() | 否 | 启动一个线程,在新线程中执行run方法中的代码 | start方法只是让线程就绪,并不是马上执行(CPU时间片还没分配给它),start方法只能调用一次,再次调用会报IllegalThreadStateException |
run() | 否 | 新线程启动之后会调用的方法 | 如果在Thread的构造方法传入了Runnable参数,则线程启动执行Runnable的run方法,否则不执行任何操作。可以继承Thread来重写run方法,覆盖默认行为 |
join() | 否 | 等待线程运行结束 | |
join(long n) | 否 | 等待线程运行结束,最多等待n毫秒 | |
getId() | 否 | 获取线程的长整型id | id唯一 |
getName() | 否 | 获取线程名 | |
setName(String) | 否 | 设置线程名 | |
getPriority() | 否 | 获取线程优先级 | |
setPriority(int) | 否 | 设置线程优先级 | java规定线程优先级是1-10的整数,数值越大优先级越高,被cpu调度的概率越大 |
getState() | 否 | 获取线程状态 | 线程状态有6中,定义在枚举中:NEW、RUNNABLE、BLOCKED、WAIT、TIMED_WAIT、TERMINATED |
isAlive() | 否 | 线程是否存活(尚未运行完) | |
interruput() | 否 | 给线程添加中断标记 | RUNNABLE、BLOCKED状态的线程只是添加中断标记,不会改变状态。WAITING、TIMED_WAITING状态的线程会抛出异常InterruptedException,并将线程状态改为RUNNABLE,同时清除中断标记 |
isInterrupted() | 否 | 判断当前线程的中断标记,不会清除标记 | |
interrupted() | 是 | 判断当前线程的中断标记,会清除标记 | |
currentThread() | 是 | 获取当前正在运行的线程对象 | |
sleep(long n) | 是 | 让当前正在运行的线程休眠n毫秒,让出cpu时间片,但不会释放锁 | |
yield() | 是 | 让出cpu时间片,进入就绪状态,重新等待调度,会释放锁 | 主要用于测试和调试 |
二、主要方法详解
2.1 start与run
start可以启动一个线程,run里面操作可以看做线程的任务。直接调用run方法,会在主线程执行run里面的操作,这块比较简单就不写demo了。
2.2 sleep与yield
sleep:
- RUNNABLE(running)状态进入TIMED_WAITING
- 其他线程可以使用interrupt方法打断正在睡眠的线程,抛出InterruptedException
- 打断之后睡眠结束,但未必立即执行
- 建议使用TimeUnit的sleep代替Thread的sleep
演示代码:
public class SleepAndYield {
public static void main(String[] args) {
Thread t1 = new Thread(() -> {
try {
// Thread.sleep(2000);
TimeUnit.SECONDS.sleep(2);
} catch (InterruptedException e) {
e.printStackTrace();
}
},"t1");
System.out.println(t1.getState());
t1.start();
System.out.println(t1.getState());
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(t1.getState());
t1.interrupt();
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(t1.getState());
}
}
yield:
- RUNNABLE(running)状态进入RUNNABLE(runnable)
- 让出cpu时间片执行其他同优先级的线程,如果没有同优先级的线程,那么不保证当前线程的暂停效果
- 具体线程的执行依赖操作系统的任务调度器
演示代码:
public class SleepAndYield1 {
public static void main(String[] args) {
Thread t1 = new Thread(() -> {
int count =0;
while (true){
System.out.println("t1----->"+count++);
}
},"t1");
Thread t2 = new Thread(() -> {
int count =0;
while (true){
Thread.yield();
System.out.println(" t2----->"+count++);
}
},"t2");
t1.start();
t2.start();
}
}
2.2.1 Thread.yield()和Thread.sleep(0)区别
无锁下相同:
- Thread.yield()和Thread.sleep(0)都会让线程放弃剩余的cpu时间片,重新变为RUNNABLE状态,并放到同优先级线程队列的末尾等待cpu资源
有锁下不同:
- Thread.yield()会让当前线程让出持有的锁,和其他线程去争抢锁,状态变为BLOCKED
- Thread.sleep(0)并不会让出锁,依然是锁的持有者,状态还是RUNNABLE
2.3 join
join方法等待所属线程对象的线程执行结束,会阻塞调用它的线程
演示代码:
public class Join {
public static void main(String[] args) throws InterruptedException {
Thread t1 = new Thread(() -> sleep(1), "t1");
Thread t2 = new Thread(() -> sleep(2), "t2");
t1.start();
t2.start();
long start =System.currentTimeMillis();
t1.join();
t2.join();
long end =System.currentTimeMillis();
System.out.println(end-start);
}
private static void sleep(int i) {
try {
TimeUnit.SECONDS.sleep(i);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
限时等待
public class JoinN {
public static void main(String[] args) throws InterruptedException {
Thread t1 = new Thread(() -> sleep(2), "t1");
t1.start();
long start =System.currentTimeMillis();
t1.join(1000);
long end =System.currentTimeMillis();
System.out.println(end-start);
}
private static void sleep(int i) {
try {
TimeUnit.SECONDS.sleep(i);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
2.4 interrupt
RUNNABLE、BLOCKED状态的线程只是添加中断标记,不会改变状态。WAITING、TIMED_WAITING状态的线程会抛出异常InterruptedException,并将线程状态改为RUNNABLE,同时清除中断标记。
打断WAIT、TIMED_WAIT线程:
public class Interrupt1 {
public static void main(String[] args) {
Thread t1 = new Thread(() -> sleep(2), "t1");
t1.start();
sleep(1);
t1.interrupt();
System.out.println("打断标记:" + t1.isInterrupted());
}
private static void sleep(int i) {
try {
TimeUnit.SECONDS.sleep(i);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
打断RUNNABLE线程:
不能让t1线程停止运行
public class Interrupt2 {
public static void main(String[] args) {
Thread t1 = new Thread(() -> {
while (true){
}
}, "t1");
t1.start();
sleep(1);
t1.interrupt();
System.out.println("打断标记:" + t1.isInterrupted());
}
加判断让t1线程停止运行
public class Interrupt2 {
public static void main(String[] args) {
Thread t1 = new Thread(() -> {
while (true) {
if(Thread.interrupted()){
System.out.println("被打断了...");
break;
}
}
}, "t1");
t1.start();
sleep(1);
t1.interrupt();
//输出false,因为interrupted()会清除打断标记
System.out.println("打断标记:" + t1.isInterrupted());
}
private static void sleep(int i) {
try {
TimeUnit.SECONDS.sleep(i);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
2.4.1 两阶段interrupt停止线程
public class Interrupt3 {
public static void main(String[] args) throws InterruptedException {
Thread t1 = new Thread(() -> {
while (true) {
System.out.println("执行监控");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
//二阶段打断
Thread.currentThread().interrupt();
}
if(Thread.interrupted()){
System.out.println("被打断了...");
break;
}
}
}, "t1");
t1.start();
Thread.sleep(3500);
//一阶段打断,t1线程正好在睡眠中,标记的打断会被清除,因此需要在catch块添加二阶段打断
t1.interrupt();
System.out.println("打断标记:" + t1.isInterrupted());
}
}
2.4.2 interrupt打断park线程
public class Interrupt4 {
public static void main(String[] args) throws InterruptedException {
Thread t1 = new Thread(() -> {
System.out.println("before park");
LockSupport.park();
System.out.println("after interrupt");
//被标记打断的线程,再次park,无法暂停
LockSupport.park();
System.out.println("can't park");
}, "t1");
t1.start();
Thread.sleep(1000);
t1.interrupt();
System.out.println("结束");
}
}
2.5 setDaemon
setDaemon将设置线程为守护线程,顾名思义守护其他线程的线程,当没有线程需要守护,自己就强制结束了。
public class SetDaemon {
public static void main(String[] args) {
Thread t1 = new Thread(() -> {
while (true) {
System.out.println("Daemon main thread");
}
}, "t1");
t1.setDaemon(true);
t1.start();
sleep(1);
System.out.println("main thread over!");
}
private static void sleep(int i) {
try {
TimeUnit.SECONDS.sleep(i);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
三、线程状态
3.1 OS层面
OS层面有以下五种状态:初始状态–>可运行–>运行中–>阻塞–>终止
- 初始状态:在编程语言创建了线程,还未提交到操作系统进行关联
- 可运行状态:已提交到操作系统的任务调度器,等待被调度运行
- 运行状态:获得了CPU时间片正在运行,与可运行状态来回切换即CPU上下文切换
- 阻塞状态:执行阻塞任务中,例如调用阻塞IO,这时线程不占用CPU,导致上下文切换进入阻塞状态。阻塞任务完成之后会被操作系统唤醒,重新进入可运行状态等待调度。阻塞状态的线程只要不被唤醒,调度器就不会考虑调度它
- 终止状态:线程执行完毕,生命周期结束,不再转换其它状态
3.2 JVM层面
Java语言中,在Thread类定义了一个状态枚举,表示线程的状态,有以下六种:NEW、RUNNABLE、BLOCKED、WAITING、TIMED_WAITING、TERMINATED。看下六种状态对应的代码
public class ThreadState {
public static void main(String[] args) throws InterruptedException {
Thread t1 = new Thread(() -> {
}, "t1");
Thread t2 = new Thread(() -> {
while (true) {
}
}, "t2");
t2.start();
Thread t3 = new Thread(() -> {
synchronized (ThreadState.class) {
try {
t2.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}, "t3");
t3.start();
Thread t4 = new Thread(() -> sleep(1000), "t4");
t4.start();
Thread t5 = new Thread(() -> {
synchronized (ThreadState.class) {
}
}, "t5");
t5.start();
Thread t6 = new Thread(() -> {
}, "t6");
t6.start();
Thread.sleep(2);
System.out.println("t1:" + t1.getState());
System.out.println("t2:" + t2.getState());
System.out.println("t3:" + t3.getState());
System.out.println("t4:" + t4.getState());
System.out.println("t5:" + t5.getState());
System.out.println("t6:" + t6.getState());
}
private static void sleep(int i) {
try {
TimeUnit.SECONDS.sleep(i);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
再看下状态转换图简易版
- 初始状态(NEW),线程对象被创建出来就进入了初始状态
- 可运行状态(RUNNABLE),包含了操作系统中的运行、可运行、和一部分阻塞。自身又可细分为就绪和运行中
- 就绪,线程进入了调度器队列,尚未被调度
- 运行中,被调度器调度,从而获得CPU时间片正在运行
- 阻塞(BLOCKED),线程阻塞在进入synchronized关键字修饰的方法或代码块(获取锁)时的状态
- 等待(WAITING),进入等待的线程,需要被显示唤醒才能再次进入可运行状态,否则将一直等待下去
- 超时等待(TIMED_WAITING)与等待状态的区别是,有时间期限,到时自动唤醒
- 终止(TERMINATED),run方法里的任务执行完就进入终止状态,线程对象也许还存活,但无法再次调用start,否则将抛出异常
3.3 OS与JVM线程状态对比
如图所示:开始和终止状态一样的,java中将就绪和运行合并为可运行,将阻塞细分为阻塞、等待和超时等待。值得注意的是,操作系统中一部分阻塞,在java中认为是可运行状态,例如IO阻塞。