第二章 java线程的状态切换及常用方法上

1.线程的五大状态及其切换

   线程的五大状态是指初始状态（New）、可运行状态（Runnable）、运行状态（Running）、阻塞状态（Blocked）、死亡状态（Dead）。

   以下是五种状态的关系切换图：

 

   

  1）初始状态：即单纯地创建一个线程，创建线程有三种方式，可参考我的博客线程创建的三种方式

（2）可运行状态：即就绪状态，在初始化了线程对象之后，调用线程对象的的start()方法来启动一个线程，即表示线程进入就绪状态！

（3）运行状态：当线程获得CPU时间片时，线程才从就绪状态进入到运行状态！

（4）阻塞状态：线程进入运行状态后，可能由于多种原因让线程进入阻塞状态，如：调用sleep()方法让线程睡眠，调用wait()方法让线程等待，调用join()方法、suspend()方法（已被弃用，容易造成死锁）以及阻塞式IO方法。

（5）死亡状态：run()方法的正常退出或者由于异常没有捕获导致的退出，则线程进入死亡状态

2.常用方法介绍

 这里不介绍stop()，resume(),suspend()方法。这三个方法不建议使用，stop()会导致线程不会正确释放资源，suspend()容易导致死锁。

2.1 yield方法

 

 方法意义：让出cpu的执行权，将线程从运行状态转到可运行状态，但是下个时间片，该线程依然有可能被再次选中运行。

 特点：不会释放获取到的锁，不能控制交出cpu的时间

 代码示例：

public class YieldTest implements Runnable{

    public static void main(String []arg){
        YieldTest yieldTest = new YieldTest();
        //启动三个进程
        for(int i=0;i<3;i++){
            Thread thread = new Thread(yieldTest);
            thread.start();
        }
    }
    @Override
    public void run() {
        for(int i=1;i<=5;i++){
            System.out.println(Thread.currentThread().getName()+":"+i);
            //使用yield方法，让出当前的cpu时间片
            Thread.yield();
        }
    }
}

 其中的一次运行结果，每次的运行结果是不一样的：

结果分析：

从代码中看，线程每次打印一个结果，都会让出cpu时间片。然后cpu再选一个线程进入可运行状态，有可能再次选到上次的那个线程

2.2 sleep和join方法

  方法意义：

  sleep和join方法都会让当前线程从运行状态进入阻塞状态。

  sleep方法可以设置休眠时间，在这段休眠时间内，不会释放它获取的锁，如果在休眠过程中线程被关闭，将会发生异常。

  join方法是指线程A执行了线程B的join方法，线程A必须要等待线程B执行完成了以后，线程A才能继续自己的工作。join方法会释放它获取到的锁,其本质用的wait/notify原理。

  这里只列出join方法的示例，sleep方法较简单。

  代码示例：

public class JoinTest implements Runnable{

    public static void main(String []arg) throws InterruptedException {
        JoinTest yieldTest = new JoinTest();
        Thread threadA = new Thread(yieldTest);
        threadA.setName("线程A");
        threadA.start();
        //不设置等待时间，主进程会一直阻塞到这里
        threadA.join();
        Thread threadB = new Thread(yieldTest);
        threadB.setName("线程B");
        threadB.start();
        //可以设置等待时间，单位ms
        threadB.join(10);
        Thread threadC = new Thread(yieldTest);
        threadC.setName("线程C");
        threadC.start();
    }
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+":开始任务");
        try {
            //sleep会中断异常
            Thread.sleep(15);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+":已完成任务");
    }
}

   运行结果：

    

    运行结果分析：

     线程A执行完，线程B才开始执行。线程B在执行过程中，由于睡眠了15ms，而主线程设置的只是等待线程B10ms的时间。所以在线程B还没有完成任务之前，线程C就开始了执行任务。

2.3 interrupt()方法

方法意义：

java线程是协作式，而非抢占式调用一个线程的interrupt() 方法中断一个线程，并不是强行关闭这个线程，只是跟这个线程打个招呼，将线程的中断标志位置为true，线程是否中断，由线程本身决定。

经常用在线程a与线程b，在业务中，常常因为线程之前的业务关系，需要互相影响，甚至是a去中断b，Thread.interrupt()提供了这样一个操作。这种方法可能会让被中断的线程抛出InterruptedException，线程的中断标志位会被复位成false，如果确实是需要中断线程，要求我们自己在catch语句块里再次调用interrupt()。

相关的两个方法：

isInterrupted()： 判定当前线程是否处于中断状态

 

interrupted()： 判定当前线程是否处于中断状态，同时中断标志位改为false。

示例代码：

public class InterruptTest {
    public static  void main(String []args){
        final Thread threadA = new Thread("线程A"){
          @Override
          public void run(){
             System.out.println(this.getName()+":我正在做一些事情");
             while(!this.isInterrupted()){
                 try {
                     Thread.sleep(2000);
                 }catch (InterruptedException ex){
                     //抛出InterruptedException异常，会使中断状态重新变为false
                     System.out.println(this.getName()+"发生了中断异常,中断状态："+this.isInterrupted());
                     //重新置为中断状态
                     this.interrupt();
                 }
             }
             //发生了中断，线程依旧或者
              System.out.println(this.getName()+"发生了中断，但依旧活着");
             //把中断状态职位非中断状态
              System.out.println(this.getName()+"中断状态："+this.isInterrupted());
              Thread.interrupted();
              System.out.println(this.getName()+"中断状态："+this.isInterrupted());
          }
        };
        threadA.start();

        Thread threadB= new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+":我正在做一些事情");
                System.out.println(Thread.currentThread().getName()+":我向线程A发送中断命令");
                threadA.interrupt();

            }
        },"线程B");
        threadB.start();
    }
}

运行结果：

结果分析：

由运行结果可以更好的看出interrupt、isInterrupted、interrupted三个方法的作用。线程发生中断，并不会导致线程进入死亡状态，只需要根据该状态进行相应的逻辑处理。

下一章节会讲述跟锁相关的线程基本方法。