线程状态05.md

线程的状态

线程的五个状态

创建状态：new一个线程对象的就进入创建状态
就绪状态：当调用start()方法,线程立即进入就绪
阻塞状态：当调用sleep，wait或同步锁定时，线程进入阻塞状态，就是代码不往下执行。阻塞事件解除后，重新进入就绪状态，等待CPU调度执行。
运行状态:进入运行专题，线程才真正执行线程体的代码块
死亡状态：线程中断或者结束，一入死亡状态，就不能再次启动

线程方法

方法	说明
setPriority(int newPriority)	更改线程的优先级
static void sleep(long millis)	在指定的毫秒数内让当前线程休眠
void join()	等待该线程终止
static void yield	（线程礼让）暂停当前正在执行的线程对象，并执行其他线程
void interrupt()	中断线程，但是别用这个方式
boolean isAlive()	测试线程是否处于活动状态

线程的停止

不推荐使用JDK提供的stop()，destroy()方法。[已废弃]
推荐线程自己停下来
建议使用一个标志位进行终止变量.当flag=false，则终止线程运行

//停止线程的
public class ThreadStop   {
	public static void main(String args[])
	{
		Threaddemo1 test01=new Threaddemo1();
		Thread  t1=new Thread(test01,"测试线程01");
		t1.start();
		for(int i=0;i<10;i++) {
			 try {
				 System.out.print("主线程main执行中++++"+i);
					Thread.sleep(1000);
				  } catch (InterruptedException e) {
					e.printStackTrace();
				  }
			if(i==7)
			{
            test01.myStop();//调用mystop方法停止线程
			}
		}
}	
}
class Threaddemo1 implements Runnable{
	//1线程中定义线程使用的标志
    private boolean Flags=true;
	@Override
	public void run() {
      //2线程体中使用该标志
      while(Flags) {
    	  
    	  try {
			Thread.sleep(1000);//测试加入延时。避免跑的过快
		  } catch (InterruptedException e) {
			e.printStackTrace();
		  }
    	  System.out.println("当前子线程启动中-----------"+Thread.currentThread().getName());
      }
      System.out.println("当前子线程已停止----------"+Thread.currentThread().getName());
	}
	//3.对外提供个一个修改标志位的方法
	public void myStop() {
		this.Flags=false;
		System.out.println("调用线程停止方法mystop");
	}
}
/*主线程main执行中++++0当前子线程启动中-----------测试线程01
主线程main执行中++++1当前子线程启动中-----------测试线程01
主线程main执行中++++2当前子线程启动中-----------测试线程01
主线程main执行中++++3当前子线程启动中-----------测试线程01
主线程main执行中++++4当前子线程启动中-----------测试线程01
主线程main执行中++++5当前子线程启动中-----------测试线程01
主线程main执行中++++6当前子线程启动中-----------测试线程01
主线程main执行中++++7当前子线程启动中-----------测试线程01
调用线程停止方法mystop
主线程main执行中++++8当前子线程启动中-----------测试线程01
当前子线程已停止----------测试线程01
主线程main执行中++++9*/

线程的休眠

sleep(时间)指定当前线程阻塞的毫秒数；
sleep存在异常InterruptedException;
sleep时间到达后线程进入就绪状态；
sleep可以模拟网络延时，倒计时等
每一个对象都有一个锁，sleep不会释放锁

import java.text.SimpleDateFormat;
import java.util.Date;
//sleep的一个作用2模拟倒计时；
public class ThreadSleep02 implements Runnable {
	@Override
	public void run() {
		int i=10;
		while(i>0) {
	     try {
			Thread.currentThread().sleep(1000);
		 } catch (InterruptedException e) {
			e.printStackTrace();
		 }
		 Date d=new Date (System.currentTimeMillis());//获取系统当前时间
		 System.out.println(new SimpleDateFormat("MM_dd_HH:MM:ss").format(d));//匹配格式打印输出
		 i--;
		}
	}
	public static void main(String args[])
	{
		new Thread(new ThreadSleep02()).start();
		
	}

}/*
 * 09_12_16:09:03
09_12_16:09:05
09_12_16:09:06
09_12_16:09:07
09_12_16:09:08
09_12_16:09:09
09_12_16:09:10
09_12_16:09:11
09_12_16:09:12
09_12_16:09:13*/

线程的礼让

礼让线程，让当前正在执行的线程暂停，但不阻塞
将线程从运行状态转为就绪状态
让cpu重新调度，礼让不一定成功！看cpu心情。

线程的合并Join

Join合并线程，待此线程执行完成后，再执行其他线程，其他线程阻塞
可以想象成插队。

public class ThreadJoin implements Runnable  {

	public void run() {
		
		for (int i=0;i<5;i++) {
		
			System.out.println("当前进程为----"+Thread.currentThread().getName()+"---"+i+"---");
					
		}
	}
	public static void main(String args[]) {
		 ThreadJoin t=new ThreadJoin();
		  Thread thr=new Thread(t,"测试子进程");
		  thr.start();
		  
          for (int i=0;i<5;i++) {
			       if(i==2) {
				 try {
			            thr.join();//注意是要插队的线程对象调用join方法
						} catch (InterruptedException e) {
							
							e.printStackTrace();
						}
			}
			System.out.println("当前进程为----"+Thread.currentThread().getName()+"---"+i+"---");s			
		}		
	}	
}
/*当前进程为----main---0---
当前进程为----测试子进程---0---
当前进程为----main---1---
当前进程为----测试子进程---1---
当前进程为----测试子进程---2---
当前进程为----测试子进程---3---
当前进程为----测试子进程---4---
当前进程为----main---2---
当前进程为----main---3---
当前进程为----main---4---
*/

观测线程的状态Thread.State

Thread.State线程的状态，线程可以处于以下状态之一：

NEW 尚未启动的线程处于此状态。
RUNNABLE 在Java虚拟机中执行的线程处于此状态
BLOCKED 被阻塞等待监视器锁定的线程处于此状态
WAITING 正在等待另一个线程执行特定动作的线程处于此状态
TIMED_WAITING 正在等待另一个线程执行动作达到指定等待时间的线程处于此状态
TERMINATED 已退出的线程处于此状态

一个线程可以给定时间点处于一个状态。这些状态是不反映任何操作系统线程状态的虚拟机状态

package com.cnblo.www.threadstate;

public class ThreadStateTest01  {
	
	public static void main(String args[]) throws InterruptedException {
		
		Thread.State stat1;
		
		Thread t1=new Thread(
				()->
		    {
		   try {
			Thread.sleep(4000);
		   } catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		   }
			for(int j=0;j<5;j++) {
				System.out.println("-------------子线程执行中--------------"+Thread.currentThread().getState());
			 }
		  }
		);
		System.out.println();
		stat1=t1.getState();
		System.out.println("当前线程状态----"+stat1);
		t1.start();
		System.out.println("当前线程状态----"+stat1);
		while(stat1!=Thread.State.TERMINATED) 
		{
			Thread.sleep(1000);
			stat1=t1.getState();
			System.out.println("--当前线程状态---"+stat1);
			
		}
		
	}

	
}/*
当前线程状态----NEW
当前线程状态----NEW
--当前线程状态---TIMED_WAITING
--当前线程状态---TIMED_WAITING
--当前线程状态---TIMED_WAITING
-------------子线程执行中--------------RUNNABLE
-------------子线程执行中--------------RUNNABLE
-------------子线程执行中--------------RUNNABLE
-------------子线程执行中--------------RUNNABLE
-------------子线程执行中--------------RUNNABLE
--当前线程状态---TERMINATED*/

注意：死亡之后的线程不能再启动了

线程的优先级

java提供一个线程调度器来监控程序中启动后进入就绪状态的所有线程，线程调度器安装优先决定应该调度哪个线程来执行。
线程的优先级用数字表示，范围1~10
- Thread.MIN_PRIORITY=1;
- Thread..MIN_PRIORITY=10;
- Thread..MIN_PRIORITY=5;
使用以下方式改变获取优先级
- getPriority().setPriority(int xxxx)

package com.cnblo.www.threadstate;

public class ThreadPriorityTest {
	
	public static void main(String args[]) {
		
		
		Runnable b=()->{
			System.out.println(Thread.currentThread().getName()+"---优先级---"+Thread.currentThread().getPriority());
		};
		Thread t1=new Thread(b);
		Thread t2=new Thread(b);
		Thread t3=new Thread(b);
		Thread t4=new Thread(b);
		Thread t5=new Thread(b);
		t1.setPriority(1);
		t2.setPriority(Thread.MAX_PRIORITY);
		t3.setPriority(4);
		t4.setPriority(8);
		t1.start();
		t2.start();
		t3.start();
		t4.start();
		System.out.println(Thread.currentThread().getName()+"---优先级---"+Thread.currentThread().getPriority());
	}
	

}
/*main---优先级---5
Thread-1---优先级---10
Thread-2---优先级---4
Thread-3---优先级---8
Thread-0---优先级---1
*/

注意：优先级的设定建议在star()调度前

优先级低只是意味着获得调度的概率低。并不是优先级低就不会被调用了，这都是看CPU的调度

posted @ 2025-12-30 10:53 翻滚的小井蛙阅读(7) 评论(0) 收藏举报

刷新页面返回顶部