线程状态
五大状态：
图示：
- NEW:Thread t = new Thread()线程对象一旦创建就进入到
了新生状态; - 就绪状态:当调用start()方法，线程立即进入就绪状态，但不意味着立即调度执行;
- 运行状态：进入运行状态，线程才真正执行线程体的代码块；
- 阻塞状态：当调用sleep，wait 或同步锁定时，线程进入阻塞状态，就是代码不往下执行，阻塞事件解除后，重新进入就绪状态，等待cpu调度执行；
- dead：线程中断或者结束，一旦进入死亡状态，就不能再次启动；
线程方法
- setPriority(int newPriority) 更改线程的优先级
- static void sleep(long millis) 在指定的毫秒数内让当前正在执行的线程休眠
- void join() 等待该线程终止
- static void yield() 暂停当前正在执行的线程对象，并执行其他线程
- void interrupt() 中断线程，别用这个方式
- boolean isAlive() 测试线程是否处于活动状态
停止线程
- 不推荐使用JDK提供的 stop()、destroy()方法。【已废弃】
- 推荐线程自己停止下来
- 建议使用一个标志位进行终止变量
当flag=false，则终止线程运行。
public class Test02 implements Runnable {
boolean flag=true;
@Override
public void run() {
while (flag){
System.out.println("run ......Thread");
}
}
private void stop(){
this.flag=false;
}
}
线程休眠(sleep)
- sleep (时间) 指定当前线程阻塞的毫秒数；
- sleep存在异常InterruptedException；
- sleep时间达到后线程进入就绪状态；
- sleep可以模拟网络延时，倒计时等。
- 每一个对象都有一个锁，sleep不会释放锁；
案例一：
//sleep,模拟休眠 , 扩大问题的发生性.
public class TestSleep1 implements Runnable {
//票
private int ticketNums = 10;
@Override
public void run() {
test();
}
public void test(){
//执行体
while (true){
if (ticketNums<=0){
break;
}
//模拟延时
try {
Thread.sleep(200);
} catch (InterruptedException e) {
e.printStackTrace();
}
//获取线程名字
System.out.println(Thread.currentThread().getName()+"-->抢到了第"+ticketNums--+"张票");
}
}
public static void main(String[] args) {
TestSleep1 t = new TestSleep1();
//第二个参数，创建线程名字
new Thread(t,"小明").start();
new Thread(t,"老师").start();
new Thread(t,"黄牛党").start();
}
}
案例二：
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Locale;
public class TestSleep2 {
public static void main(String[] args) throws InterruptedException {
TestSleep2 testSleep2 = new TestSleep2();
//获取系统时间
Date startTime = new Date(System.currentTimeMillis());
while (true) {
System.out.println(new SimpleDateFormat("HH:mm:ss").format(startTime));
Thread.sleep(1000);
startTime = new Date(System.currentTimeMillis());
}
}
//倒计时方法
private void tenDown() throws InterruptedException {
int num = 10;
for (int i = 10; i > 0; i--) {
Thread.sleep(1000);
System.out.println("倒计时:"+i);
}
}
}
线程礼让(yield)
- 礼让线程，让当前正在执行的线程暂停，但不阻塞
- 将线程从运行状态转为就绪状态
- 让cpu重新调度，礼让不一定成功！看CPU心情
案例：
//线程的礼让
public class TestYield {
public static void main(String[] args) throws InterruptedException {
MyYield myYield = new MyYield();
new Thread(myYield,"小明").start();
new Thread(myYield,"老师").start();
}
}
class MyYield implements Runnable{
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+"-->启动了");
Thread.yield();//礼让
System.out.println(Thread.currentThread().getName()+"-->停止了");
}
}
Join
- Join合并线程，待此线程执行完成后，再执行其他线程，其他线程阻塞
- 可以想象成插队
案例：
//线程强制执行
public class TestJoin implements Runnable{
public static void main(String[] args) throws InterruptedException {
TestJoin testJoin = new TestJoin();
Thread thread = new Thread(testJoin);
thread.start();
for (int i = 0; i < 100; i++) {
if (i==80){
//强制执行
thread.join();
}
System.out.println("我是主线程:"+i);
}
}
@Override
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println("我是要插队的线程:"+i);
}
}
}
/*
Blocked
New
Run
Terminated : 终止
wait():等待
*/
案例二：
//测试join方法
public class TestJoin2 {
public static void main(String[] args) {
new Teacher().start();
}
}
class Teacher extends Thread{
@Override
public void run() {
System.out.println("老师:小明,你留下来写作业");
System.out.println("老师:放学别走,我们两谈一谈");
Thread xm = new Thread(new XiaoMing());
xm.start();
//小明插队执行
try {
xm.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("老师:你可以走了");
}
}
class XiaoMing implements Runnable{
@Override
public void run() {
System.out.println("小明:好的老师,我写作业");
for (int i = 10; i > 0 ; i--) {
//模拟延时
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("小明:正在写作业..."+i);
}
System.out.println("小明:老师我作业写完了");
}
}
线程状态观测
- Thread.State
- 线程可以处于以下状态之一：
- NEW：尚未启动的线程处于此状态；
- RUNNABLE:在Java虚拟机中执行的线程处于此状态；
- BLOCKED:被阻塞等待监视器锁定的线程处于此状态；
- Waitting:在等待另外一个线程执行特定动作的线程处于此状态；
- TIMED WAITTING：在等待另外一个线程执行特定动作达到指定等待时间的线程处于此状态
- TERMINTED:已退出的线程处于此状态；
案例：
import javax.swing.plaf.BorderUIResource;
//观测线程的状态
public class TestState {
public static void main(String[] args) throws InterruptedException {
Thread thread = new Thread(()->{
for (int i = 0; i < 5; i++) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
}
}
线程的优先级
- Java提供一个线程调度器来监控程序中启动后进入就绪状态的所有线程，线程调度器按照优先级决定应该调度哪个线程来执行。
- 线程的优先级用数字表示，范围从1~10.
Thread.MIN_PRIORITY = 1;
Thread.MAX_PRIORITY = 10;
Thread.NORM_PRIORITY = 5; - 使用以下方式改变或获取优先级
getPriority() . setPriority(int xxx) - 优先级的设定建议在start()调度前
优先级低只是意味着获得调度的概率低.并不是优先级低就不会被调用了.这都是看CPU的调度
案例：
//测试线程优先级
public class TestPriority {
public static void main(String[] args) {
System.out.println(Thread.currentThread().getName()+"-->"+Thread.currentThread().getPriority());
MyPriority myPriority = new MyPriority();
Thread thread1 = new Thread(myPriority);
Thread thread2 = new Thread(myPriority);
Thread thread3 = new Thread(myPriority);
Thread thread4 = new Thread(myPriority);
Thread thread5 = new Thread(myPriority);
thread1.setPriority(1);
thread1.start();
thread2.setPriority(4);
thread2.start();
thread3.setPriority(8);
thread3.start();
thread4.setPriority(9);
thread4.start();
thread5.setPriority(10);
thread5.start();
}
}
class MyPriority implements Runnable{
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+"-->"+Thread.currentThread().getPriority());
}
}
守护(daemon)线程
- 线程分为用户线程和守护线程
- 虚拟机必须确保用户线程执行完毕
- 虚拟机不用等待守护线程执行完毕
- 如,后台记录操作日志,监控内存,垃圾回收等待
案例：
//测试守护线程
//用户线程: 虚拟机要等待用户线程执行完毕
//守护线程: 虚拟机 不用等待 守护线程 执行完毕
public class TestDaemon {
public static void main(String[] args) {
God god = new God();
Thread thread = new Thread(god);
thread.setDaemon(true); //设置线程为守护线程,默认为false
thread.start();
//用户线程
new Thread(()->{
for (int i = 0; i < 30; i++) {
System.out.println("你开心的在这个世界上活着"+i);
}
System.out.println("=======Goodbye , World!");
}).start();
}
}
//守护线程
class God implements Runnable{
@Override
public void run() {
for (;true;){
System.out.println("上帝保佑着你");
}
}
}
扫一扫
560
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
