Day Seventeen
线程的五大状态
- new的时候就是创建状态“new Thread()”,调用了start方法就是启动了,进入就绪状态,然后等待CPU的调度,调度完了之后才进入运行状态,如果线程调用了sleep方法就会进入阻塞状态(有很多方法都可以进入阻塞态,sleep只是其中一个),阻塞解除后会进入就绪态,如果正常执行完,就进入死亡状态。
我们来看一个详细一点的图:
线程方法
方法 | 说明 |
---|---|
setPriority(int newPriority) | 更改线程的优先级 |
static void sleep(long millis) | 在指定的毫秒数内让当前正在执行的线程休眠 |
void join() | 等待该线程终止 |
static void yield() | 暂停当前的正在执行的线程对象,并执行其他线程 |
void interrupt() | 中断线程,别用这个方式 |
boolean isAlive() | 测试线程是否处于活动状态 |
停止线程
- 不推荐使用JDK提供的stop()、destroy()方法。都已废弃。
- 推荐线程自己停止下来
- 建议使用一个标志位进行终止变量,当flag=false,则终止线程运行。
package com.liuHuan.thread;
public class TestStop implements Runnable{
//1. 线程中定义线程体使用的标识
private boolean flag = true;
@Override
public void run() {
int i = 0;
//2.线程体使用该标识
while (flag) {
System.out.println("run.........Thread" + i++);
}
}
//主方法
public static void main(String[] args) {
TestStop testStop = new TestStop();
new Thread(testStop).start();
for (int i = 0; i < 100; i++) {
System.out.println("main" + i);
if (i == 90) {
//调用stop方法切换标志位,让线程停止
testStop.stop();
System.out.println("线程该停止了");
}
}
}
//3.对外提供方法改变标识
public void stop() {
this.flag = false;
}
}
线程休眠
- sleep(时间)指定当前线程阻塞的毫秒数
- sleep存在异常InterruptedException
- sleep时间达到后,线程进入就绪状态
- sleep可以模拟网络延时(放大问题的安全性),倒计时等
- 每个对象都有一个锁,sleep不会释放锁
用代码来实现模拟网络时延:
package com.liuHuan.thread;
public class TestSleep implements Runnable{
private int nums = 10;
@Override
public void run() {
while (true) {
if (nums <= 0){
break;
}
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "拿到了第 " + nums-- + "张票");
}
}
public static void main(String[] args) {
TestSleep testSleep = new TestSleep();
new Thread(testSleep,"大黄").start();
new Thread(testSleep,"小黑").start();
new Thread(testSleep,"二狗").start();
}
}
模拟倒计时:
package com.liuHuan.thread;
import java.text.SimpleDateFormat;
import java.util.Date;
public class TestCountDown {
public static void main(String[] args) {
printTime();
}
//打印当前系统时间
public static void printTime(){
//获取系统当前时间
Date starTime = new Date(System.currentTimeMillis());
while (true){
try {
Thread.sleep(1000);
System.out.println(new SimpleDateFormat("HH:mm:ss").format(starTime));
//更新当前时间
starTime = new Date(System.currentTimeMillis());
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
//模拟倒计时
public static void tenDown(){
int num = 10;
while (true){
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(num--);
if (num == 0){
break;
}
}
}
}
线程休眠_yield
- 礼让线程,让当前正在执行的线程暂停,但不阻塞
- 讲线程从运行状态转为就绪状态
- 让CPU重新调度,礼让不一定成功!!看CPU心情。
package com.liuHuan.thread;
//测试礼让线程
// 礼让不一定成功,看CPU心情
public class TestYield {
public static void main(String[] args) {
yield yield = new yield();
new Thread(yield,"a").start();
new Thread(yield,"b").start();
}
}
class yield implements Runnable{
@Override
public void run() {
System.out.println(Thread.currentThread().getName() + "开始执行");
Thread.yield();
System.out.println(Thread.currentThread().getName() + "结束执行");
}
}
线程强制执行_join
- join合并线程,待此线程执行完成后,再执行其他线程,其他线程阻塞。
- 就是TMD插队,可以这样理解。实际中尽量不要用。
package com.liuHuan.thread;
public class TestJoin implements Runnable{
public static void main(String[] args) {
TestJoin testJoin = new TestJoin();
Thread thread = new Thread(testJoin);
thread.start();
for (int i = 0; i < 10; i++) {
if (i == 5) {
try {
thread.join();//main线程阻塞
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("main...." + i);
}
}
@Override
public void run() {
for (int i = 0; i < 10; i++) {
System.out.println("join......." + i);
}
}
}
线程状态观测
- Thread.State 线程状态。线程可以处于以下状态之一
- NEW:尚未启动的线程处于此状态。
- RUNNABLE:在Java虚拟机中执行的线程处于此状态。
- BLOCKED:被阻塞等待监视器锁定的线程处于此状态。
- WAITING:正在等待另一个线程执行特定动作的线程处于此状态。
- TIMED_WAITING:正在等待另一个线程执行动作达到指定等待时间的线程处于此状态。
- TERMINATED:已退出的线程处于此状态。
- 一个线程可以在给定的时间点处于一个状态。这些状态是不反映任何操作系统线程状态的虚拟机状态。
package com.liuHuan.thread;
//观察测试线程的状态
public class TestState {
public static void main(String[] args) throws InterruptedException {
Thread thread = new Thread(() -> {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("==========");
});
//观察线程状态
Thread.State state = thread.getState();
System.out.println(state);
//观察启动后
thread.start();
state = thread.getState();
System.out.println(state);
//只要线程不终止,就一直返回状态
while (state != Thread.State.TERMINATED) {
Thread.sleep(100);
state = thread.getState();
System.out.println(state);
}
}
}