本篇文章给大家分享的是有关Java中的线程有哪些状态，小编觉得挺实用的，因此分享给大家学习，希望大家阅读完这篇文章后可以有所收获，话不多说，跟着小编一起来看看吧。
Java中线程的状态分为6种。
1. 初始(NEW) ：新创建了一个线程对象，但还没有调用start()方法。
2.运行(RUNNABLE) ：Java线程中将就绪（ready）和运行中（running）两种状态笼统的称为“运行”。线程对象创建后，其他线程(比如main线程）调用了该对象的start()方法。该状态的线程位于可运行线程池中，等待被线程调度选中，获取CPU的使用权，此时处于就绪状态（ready）。就绪状态的线程在获得CPU时间片后变为运行中状态（running）。
3. 阻塞(BLOCKED) ：表示线程阻塞于锁。
4. 等待(WAITING) ：进入该状态的线程需要等待其他线程做出一些特定动作（通知或中断）。
5. 超时等待(TIMED_WAITING) ：该状态不同于WAITING，它可以在指定的时间后自行返回。
6.终止(TERMINATED) ：表示该线程已经执行完毕。
这6种状态定义在Thread类的State枚举中，可查看源码进行一一对应。
实现Runnable接口和继承Thread可以得到一个线程类，new一个实例出来，线程就进入了初始状态。
线程调度程序从可运行池中选择一个线程作为当前线程时线程所处的状态。这也是线程进入运行状态的唯一的一种方式。
阻塞状态是线程阻塞在进入synchronized关键字修饰的方法或代码块(获取锁)时的状态。
处于这种状态的线程不会被分配CPU执行时间，它们要等待被显式地唤醒，否则会处于无限期等待的状态。
处于这种状态的线程不会被分配CPU执行时间，不过无须无限期等待被其他线程显示地唤醒，在达到一定时间后它们会自动唤醒。
当线程的run()方法完成时，或者主线程的main()方法完成时，我们就认为它终止了。这个线程对象也许是活的，但是它已经不是一个单独执行的线程。线程一旦终止了，就不能复生。
在一个终止的线程上调用start()方法，会抛出java.lang.IllegalThreadStateException异常。
调用obj的wait(), notify()方法前，必须获得obj锁，也就是必须写在synchronized(obj) 代码段内。
与等待队列相关的步骤和图
线程运行的过程会产生很多信息，这些信息都保存在Thread类中的成员变量里面，常见的有：
a.线程的ID是唯一标识getId()
b.线程的名称：getName()，如果不设置线程名称默认为“Thread-xx”
c.线程的优先级：getPriority，线程优先级从1-10,其中数字越大表示优先级别越高，同时获得JVM调度执行的可能性越大，JDK内置了三种常见的状态：
`//最小优先级 public final static int MIN_PRIORITY = 1; //一般优先级 public final static int NORM_PRIORITY = 5; //最大优先级 public final static int MAX_PRIORITY = 10;`
一般不推荐设置线程的优先级，如果进行设置了非法的优先级程序就会出现IllegalArgumentException异常。
继承Thread类。
步骤：
1，定义一个类继承Thread类。
2，覆盖Thread类中的run方法。
3，直接创建Thread的子类对象创建线程。
4，调用start方法开启线程并调用线程的任务run方法执行。
可以通过Thread的getName获取线程的名称 Thread-编号(从0开始)
主线程的名字就是main。
class Demo extends Thread
{
/**
*线程名称
*/
private String name;
Demo(String name)
{
//父类构造函数，改线程的名称
super(name);
//this.name = name;
}
//***run方法中定义就是线程要运行的任务代码。***
public void run()
{
for(int x=0; x<10; x++)
{
//for(int y=-9999999; y<999999999; y++){}
System.out.println(name+"....x="+x+".....name="+Thread.currentThread().getName());
}
}
}
class ThreadDemo2
{
public static void main(String[] args)
{
Demo d1 = new Demo("旺财");
Demo d2 = new Demo("xiaoqiang");
d1.start();//开启线程，调用run方法。
d2.start();
System.out.println("over...."+Thread.currentThread().getName());
}
}当该类有自己父类的时候，通过实现Runnable接口，覆盖run方法。（常用）
步骤：
1，定义类实现Runnable接口。
2，覆盖接口中的run方法，将线程的任务代码封装到run方法中。
3，通过Thread类创建线程对象，并将Runnable接口的子类对象作为Thread类的构造函数的参数进行传递。
为什么？因为线程的任务都封装在Runnable接口子类对象的run方法中。
所以要在线程对象创建时就必须明确要运行的任务。
思想：将线程的任务通过Runnable接口封装成了对象。
4，调用线程对象的start方法开启线程。
实现Runnable接口的好处：
1，将线程的任务从线程的子类中分离出来，进行了单独的封装，按照面向对象的思想将任务封装成对象。
2，避免了java单继承的局限性。
//extends Fu
//准备扩展Demo类的功能，让其中的内容可以作为线程的任务执行。
//通过接口的形式完成。
class Demo implements Runnable{
public void run()
{
show();
}
public void show()
{
for(int x=0; x<20; x++)
{
System.out.println(Thread.currentThread().getName()+"....."+x);
}
}
}
class ThreadDemo
{
public static void main(String[] args)
{
Demo d = new Demo();
Thread t1 = new Thread(d);
Thread t2 = new Thread(d);
t1.start();
t2.start();
}
}实现Callable接口
与使用Runnable相比， Callable功能更强大些
1 相比run()方法，可以有返回值
2 方法可以抛出异常
3 支持泛型的返回值
4 需要借助FutureTask类，比如获取返回结果
Future接口
1 可以对具体Runnable、Callable任务的执行结果进行取消、查询是
否完成、获取结果等。
2 FutrueTask是Futrue接口的唯一的实现类
3 FutureTask 同时实现了Runnable, Future接口。它既可以作为 Runnable被线程执行，又可以作为Future得到Callable的返回值
//1.创建一个实现Callable的实现类
class Stu implements Callable {
//2.实现call方法,将此线程需要执行的操作生命call()中
@Override
public Object call() throws Exception {
int sum=0;
for (int i = 1; i <=100; i++) {
if(i % 2 == 0){
System.out.println(i);
sum += i;
}
}
return sum;
}
}
public class Bank {
public static void main(String[] args) {
//3.创建Callable接口实现类的对象
Stu stu = new Stu();
//4.将此Callable接口实现类的对象作为传递到FutureTask构造器中，创建FutureTask的对象
FutureTask futureTask = new FutureTask(stu);
//5.FutureTask的对象作为参数传递到Thread类的构造器中创建Thread，并调用start()
new Thread(futureTask).start();
try {
Object sum = futureTask.get();
System.out.println("总和为"+sum);
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
}
}使用线程池
背景：经常创建和销毁、使用量特别大的资源，比如并发情况下的线程， 对性能影响很大。
思路：提前创建好多个线程，放入线程池中，使用时直接获取，使用完 放回池中。可以避免频繁创建销毁、实现重复利用。类似生活中的公共交 通工具。
好处:
1提高响应速度（减少了创建新线程的时间）;
2降低资源消耗（重复利用线程池中线程，不需要每次都创建）;
3便于线程管理;
corePoolSize：核心池的大小
maximumPoolSize：最大线程数
keepAliveTime：线程没有任务时最多保持多长时间后会终止
//创建并使用多线程的第四种方法：使用线程池
class MyThread implements Runnable {
@Override
public void run() {
for (int i = 1; i <= 100; i++) {
if(i % 2 ==0){
System.out.println(Thread.currentThread().getName() + ":" + i);
}
}
}
}
public class ThreadPool {
public static void main(String[] args) {
// 1.提供指定线程的数量
ExecutorService service = Executors.newFixedThreadPool(10);
//设置线程的属性
ThreadPoolExecutor service1= (ThreadPoolExecutor) service;
//service1.setMaximumPoolSize(15);
//service1.setCorePoolSize();*/
// 2.将Runnable实现类的对象作为形参传递给ExecutorService的submit()方法中，开启线程
// 并执行相关的run()
service.execute(new MyThread());//适用于Runnable
//service.submit();适用于Callable
// 3.结束线程的使用
service.shutdown();
}
}以上就是Java中的线程有哪些状态，小编相信有部分知识点可能是我们日常工作会见到或用到的。希望你能通过这篇文章学到更多知识。更多详情敬请关注亿速云行业资讯频道。
免责声明：本站发布的内容（图片、视频和文字）以原创、转载和分享为主，文章观点不代表本网站立场，如果涉及侵权请联系站长邮箱：is@yisu.com进行举报，并提供相关证据，一经查实，将立刻删除涉嫌侵权内容。
