Java线程的6种状态及切换教程

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枚举中，可查看源码进行一一对应。

一、线程的状态图

二、状态详细说明

2.1. 初始状态(new)

实现runnable接口和继承thread可以得到一个线程类，new一个实例出来，线程就进入了初始状态。

2.2. 就绪状态(runnable之ready)

1. 就绪状态只是说你资格运行，调度程序( cpu )没有挑选到你，你就永远是就绪状态。
2. 调用线程的start()方法，此线程进入就绪状态。
3. 当前线程sleep()方法结束，其他线程join()结束，等待用户输入完毕，某个线程拿到对象锁，这些线程也将进入就绪状态。
4. 当前线程时间片用完了，调用当前线程的yield()方法，当前线程进入就绪状态。
5. 锁池里的线程拿到对象锁后，进入就绪状态。
   

2.3. 运行中状态(runnable之running)

线程调度程序从可运行池中选择一个线程作为当前线程时线程所处的状态。这也是线程进入运行状态的唯一的一种方式。

3. 阻塞状态(blocked)

阻塞状态是线程阻塞在进入synchronized关键字修饰的方法或代码块(获取锁)时的状态。

4. 等待(waiting)

处于这种状态的线程不会被分配cpu执行时间，它们要等待被显式地唤醒，否则会处于无限期等待的状态。

5. 超时等待(timed_waiting)

处于这种状态的线程不会被分配cpu执行时间，不过无须无限期等待被其他线程显示地唤醒，在达到一定时间后它们会自动唤醒。

6. 终止状态(terminated)

当线程的run()方法完成时，或者主线程的main()方法完成时，我们就认为它终止了。这个线程对象也许是活的，但是它已经不是一个单独执行的线程。线程一旦终止了，就不能复生。

在一个终止的线程上调用start()方法，会抛出java.lang.illegalthreadstateexception异常。

三、等待队列

调用obj的wait(), notify()方法前，必须获得obj锁，也就是必须写在synchronized(obj) 代码段内。

与等待队列相关的步骤和图

1. 线程1获取对象a的锁，正在使用对象a。
2. 线程1调用对象a的wait()方法。
3. 线程1释放对象a的锁，并马上进入等待队列。
4. 锁池里面的对象争抢对象a的锁。
5. 线程5获得对象a的锁，进入synchronized块，使用对象a。
6. 线程5调用对象a的notifyall()方法，唤醒所有线程，所有线程进入同步队列。若线程5调用对象a的notify()方法，则唤醒一个线程，不知道会唤醒谁，被唤醒的那个线程进入同步队列。
7. notifyall()方法所在synchronized结束，线程5释放对象a的锁。
8. 同步队列的线程争抢对象锁，但线程1什么时候能抢到就不知道了。
   

四、同步队列状态

1. 当前线程想调用对象a的同步方法时，发现对象a的锁被别的线程占有，此时当前线程进入同步队列。简言之，同步队列里面放的都是想争夺对象锁的线程。
2. 当一个线程1被另外一个线程2唤醒时，1线程进入同步队列，去争夺对象锁。
3. 同步队列是在同步的环境下才有的概念，一个对象对应一个同步队列。
4. 线程等待时间到了或被notify/notifyall唤醒后，会进入同步队列竞争锁，如果获得锁，进入runnable状态，否则进入blocked状态等待获取锁。

五、几个方法的比较

1. thread.sleep(long millis)，一定是当前线程调用此方法，当前线程进入timed_waiting状态，但不释放对象锁，millis后线程自动苏醒进入就绪状态。作用：给其它线程执行机会的最佳方式。
2. thread.yield()，一定是当前线程调用此方法，当前线程放弃获取的cpu时间片，但不释放锁资源，由运行状态变为就绪状态，让os再次选择线程。 作用：让相同优先级的线程轮流执行，但并不保证一定会轮流执行。实际中无法保证yield()达到让步目的，因为让步的线程还有可能被线程调度程序再次选中。thread.yield()不会导致阻塞。该方法与sleep()类似，只是不能由用户指定暂停多长时间。
3. thread.join()/thread.join(long millis)，当前线程里调用其它线程t的join方法，当前线程进入waiting/timed_waiting状态，当前线程不会释放已经持有的对象锁。线程t执行完毕或者millis时间到，当前线程一般情况下进入runnable状态，也有可能进入blocked状态（因为join是基于wait实现的）。
4. object.wait()，当前线程调用对象的wait()方法，当前线程释放对象锁，进入等待队列。依靠notify()/notifyall()唤醒或者wait(long timeout) timeout时间到自动唤醒。
5. object.notify()唤醒在此对象监视器上等待的单个线程，选择是任意性的。notifyall()唤醒在此对象监视器上等待的所有线程。
6. locksupport.park()/locksupport.parknanos(long nanos),locksupport.parkuntil(long deadlines), 当前线程进入waiting/timed_waiting状态。对比wait方法,不需要获得锁就可以让线程进入waiting/timed_waiting状态，需要通过locksupport.unpark(thread thread)唤醒。
   

六 创建线程的几种方式

thread

线程运行的过程会产生很多信息，这些信息都保存在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线程的6种状态及切换的文章就介绍到这了,更多相关java线程状态及切换内容请搜索以前的文章或继续浏览下面的相关文章希望大家以后多多支持！